Mercurial Mercurial > oss > FCL > 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/dbms/tdbms/t_dbood.cpp
changeset 55 44f437012c90
parent 15 3eacc0623088
equal deleted inserted replaced
51:7d4490026038 55:44f437012c90 
     1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     1 // Copyright (c) 2004-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".
 
    86 
    86 
    87 	_LIT(KLargeFileName, "E:\\DBMS-TST\\DeleteMe");
 
    87 	_LIT(KLargeFileName, "E:\\DBMS-TST\\DeleteMe");
 
    88 
    88 
    89 #endif
 
    89 #endif
 
    90 
    90 
       
    91 //The drive that will be used in case if the original drive, where KTestDir is supposed to be created, is not present. 
       
    92 const TInt KTestDrive2 = EDriveC;
 
       
    93 _LIT(KTestDatabase2, "C:\\DBMS-TST\\T_DbmsOOD.DB");
 
       
    94 _LIT(KLargeFileName2, "C:\\DBMS-TST\\DeleteMe");
 
       
    95 
       
    96 TInt TheTestDrive = -1;
 
       
    97 TFileName TheTestDatabase;
 
       
    98 TFileName TheLargeFileName;
 
       
    99 
       
   100 	
    91 static void AssembleLargeFileName(const TDesC& aFileName, TInt aFileNumber, TDes& aResultPath)
 
   101 static void AssembleLargeFileName(const TDesC& aFileName, TInt aFileNumber, TDes& aResultPath)
 
    92 	{
 
   102 	{
 
    93 	_LIT(KFormatStr, "%S.%03d");
 
   103 	_LIT(KFormatStr, "%S.%03d");
 
    94 	aResultPath.Format(KFormatStr, &aFileName, aFileNumber);
 
   104 	aResultPath.Format(KFormatStr, &aFileName, aFileNumber);
 
    95 	}
 
   105 	}
 
   107 		{
 
   117 		{
 
   108 		TEntry entry;
 
   118 		TEntry entry;
 
   109 		err = fsSession.Entry(aFullName, entry);
 
   119 		err = fsSession.Entry(aFullName, entry);
 
   110 		if(err == KErrNone)
 
   120 		if(err == KErrNone)
 
   111 			{
 
   121 			{
 
   112 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);
 
   122 			TheTest.Printf(_L("Deleting \"%S\" file.\n"), &aFullName);
 
   113 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);
 
   123 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);
 
   114 			if(err != KErrNone)
 
   124 			if(err != KErrNone)
 
   115 				{
 
   125 				{
 
   116 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
 
   126 				TheTest.Printf(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
 
   117 				}
 
   127 				}
 
   118 			err = fsSession.Delete(aFullName);
 
   128 			err = fsSession.Delete(aFullName);
 
   119 			if(err != KErrNone)
 
   129 			if(err != KErrNone)
 
   120 				{
 
   130 				{
 
   121 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
 
   131 				TheTest.Printf(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
 
   122 				}
 
   132 				}
 
   123 			}
 
   133 			}
 
   124 		fsSession.Close();
 
   134 		fsSession.Close();
 
   125 		}
 
   135 		}
 
   126 	else
 
   136 	else
 
   127 		{
 
   137 		{
 
   128 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
 
   138 		TheTest.Printf(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
 
   129 		}
 
   139 		}
 
   130 	return err;
 
   140 	return err;
 
   131 	}
 
   141 	}
 
   132 
   142 
   133 //Deletes large data files only
 
   143 //Deletes large data files only
 
   134 static void DeleteLargeDataFiles()
 
   144 static void DeleteLargeDataFiles()
 
   135 	{
 
   145 	{
 
   136 	for(TInt i=0;i<1000;++i)
 
   146 	for(TInt i=0;i<1000;++i)
 
   137 		{
 
   147 		{
 
   138 		TBuf<KMaxFileName> filePath;
 
   148 		TBuf<KMaxFileName> filePath;
 
   139 		AssembleLargeFileName(KLargeFileName, i, filePath);
 
   149 		AssembleLargeFileName(TheLargeFileName, i, filePath);
 
   140 		if(DeleteDataFile(filePath) != KErrNone)
 
   150 		if(DeleteDataFile(filePath) != KErrNone)
 
   141 			{
 
   151 			{
 
   142 			break;
 
   152 			break;
 
   143 			}
 
   153 			}
 
   144 		}
 
   154 		}
 
   150 	if(TheDbSession.Handle())
 
   160 	if(TheDbSession.Handle())
 
   151 		{
 
   161 		{
 
   152 		TheDb.Close();
 
   162 		TheDb.Close();
 
   153 		}
 
   163 		}
 
   154 	TheDbSession.Close();
 
   164 	TheDbSession.Close();
 
   155 	DeleteDataFile(KTestDatabase);
 
   165 	DeleteDataFile(TheTestDatabase);
 
   156 	DeleteLargeDataFiles();
 
   166 	DeleteLargeDataFiles();
 
   157 	}
 
   167 	}
 
   158 
   168 
   159 ///////////////////////////////////////////////////////////////////////////////////////
 
   169 ///////////////////////////////////////////////////////////////////////////////////////
 
   160 ///////////////////////////////////////////////////////////////////////////////////////
 
   170 ///////////////////////////////////////////////////////////////////////////////////////
 
   162 //If (!aValue) then the test will be panicked, the test data files will be deleted.
 
   172 //If (!aValue) then the test will be panicked, the test data files will be deleted.
 
   163 static void Check(TInt aValue, TInt aLine)
 
   173 static void Check(TInt aValue, TInt aLine)
 
   164 	{
 
   174 	{
 
   165 	if(!aValue)
 
   175 	if(!aValue)
 
   166 		{
 
   176 		{
 
       
   177 		TheTest.Printf(_L("*** Expression evaluated to false\r\n"));
 
   167 		DeleteDataFiles();
 
   178 		DeleteDataFiles();
 
   168 		TheTest(EFalse, aLine);
 
   179 		TheTest(EFalse, aLine);
 
   169 		}
 
   180 		}
 
   170 	}
 
   181 	}
 
   171 //If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.
 
   182 //If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.
 
   172 static void Check(TInt aValue, TInt aExpected, TInt aLine)
 
   183 static void Check(TInt aValue, TInt aExpected, TInt aLine)
 
   173 	{
 
   184 	{
 
   174 	if(aValue != aExpected)
 
   185 	if(aValue != aExpected)
 
   175 		{
 
   186 		{
 
   176 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
 
   187 		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
 
   177 		DeleteDataFiles();
 
   188 		DeleteDataFiles();
 
   178 		TheTest(EFalse, aLine);
 
   189 		TheTest(EFalse, aLine);
 
   179 		}
 
   190 		}
 
   180 	}
 
   191 	}
 
   181 //Use these to test conditions.
 
   192 //Use these to test conditions.
 
   188 
   199 
   189 //Prepares the test directory.
 
   200 //Prepares the test directory.
 
   190 //TheFs.Connect() has to be called already.
 
   201 //TheFs.Connect() has to be called already.
 
   191 static void SetupTestDirectory()
 
   202 static void SetupTestDirectory()
 
   192     {
 
   203     {
 
   193 	TInt err = TheFs.MkDir(KTestDatabase);
 
   204 	TInt err = TheFs.MkDir(TheTestDatabase);
 
   194 	if(err != KErrNone)
 
   205 	if(err != KErrNone && err != KErrAlreadyExists)
 
   195 	    {
 
   206 	    {
 
   196 	    RDebug::Print(_L("*** SetupTestDirectory(), RFs::MkDir(), err=%d\r\n"), err);
 
   207 		TheTest.Printf(_L("*** SetupTestDirectory(), RFs::MkDir(), drive=%d, err=%d.\r\nNext attempt with drive %d.\r\n"), TheTestDrive, err, KTestDrive2);
 
       
   208 	    TheTestDrive = KTestDrive2;
 
       
   209 		TheTestDatabase.Copy(KTestDatabase2);
 
       
   210 		TheLargeFileName.Copy(KLargeFileName2);
 
       
   211 		err = TheFs.MkDir(TheTestDatabase);
 
   197 	    }
 
   212 	    }
 
   198 	TEST(err == KErrNone || err == KErrAlreadyExists);
 
   213 	TEST(err == KErrNone || err == KErrAlreadyExists);
 
   199 	}
 
   214 	}
 
   200 
   215 
   201 //Leaves with info message printed out
 
   216 //Leaves with info message printed out
 
   202 static void LeaveL(TInt aError, TInt aLine)
 
   217 static void LeaveL(TInt aError, TInt aLine)
 
   203 	{
 
   218 	{
 
   204 	RDebug::Print(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);
 
   219 	TheTest.Printf(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);
 
   205 	User::Leave(aError);
 
   220 	User::Leave(aError);
 
   206 	}
 
   221 	}
 
   207 
   222 
   208 //Leaves if aError < 0 with info message printed out
 
   223 //Leaves if aError < 0 with info message printed out
 
   209 static void LeaveIfErrorL(TInt aError, TInt aLine)
 
   224 static void LeaveIfErrorL(TInt aError, TInt aLine)
 
   238 
   253 
   239 //Gets the available space of the tested drive.
 
   254 //Gets the available space of the tested drive.
 
   240 static TInt64 FreeDiskSpaceL()
 
   255 static TInt64 FreeDiskSpaceL()
 
   241 	{
 
   256 	{
 
   242 	TVolumeInfo volInfoBefore;
 
   257 	TVolumeInfo volInfoBefore;
 
   243 	LEAVE_IF_ERROR(TheFs.Volume(volInfoBefore, KTestDrive));
 
   258 	LEAVE_IF_ERROR(TheFs.Volume(volInfoBefore, TheTestDrive));
 
   244 	return volInfoBefore.iFree;
 
   259 	return volInfoBefore.iFree;
 
   245 	}
 
   260 	}
 
   246 
   261 
   247 //Creates large data file with aSize size (in bytes).
 
   262 //Creates large data file with aSize size (in bytes).
 
   248 static void DoCreateLargeFileL(const TDesC& aPath, TInt aSize)
 
   263 static void DoCreateLargeFileL(const TDesC& aPath, TInt aSize)
 
   260 static void CreateLargeFileL()
 
   275 static void CreateLargeFileL()
 
   261 	{
 
   276 	{
 
   262 	TInt fileNo = 0;
 
   277 	TInt fileNo = 0;
 
   263 	const TInt KLargeFileSize = 1000000000;
 
   278 	const TInt KLargeFileSize = 1000000000;
 
   264 	TInt64 diskSpace = FreeDiskSpaceL();
 
   279 	TInt64 diskSpace = FreeDiskSpaceL();
 
   265 	RDebug::Print(_L("CreateLargeFileL: free space before = %ld\n"), diskSpace);
 
   280 	TheTest.Printf(_L("CreateLargeFileL: free space before = %ld\n"), diskSpace);
 
   266 	TBuf<KMaxFileName> filePath;
 
   281 	TBuf<KMaxFileName> filePath;
 
   267     const TInt64 KMinDiskSpace = 200;
 
   282     const TInt64 KMinDiskSpace = 200;
 
   268 	//Reserve almost all disk space, except a small amount - 200 bytes.
 
   283 	//Reserve almost all disk space, except a small amount - 200 bytes.
 
   269 	while(diskSpace > KMinDiskSpace)
 
   284 	while(diskSpace > KMinDiskSpace)
 
   270 		{
 
   285 		{
 
   271 		AssembleLargeFileName(KLargeFileName, fileNo++, filePath);
 
   286 		AssembleLargeFileName(TheLargeFileName, fileNo++, filePath);
 
   272 		TInt fileSize = KLargeFileSize;
 
   287 		TInt fileSize = KLargeFileSize;
 
   273         if(diskSpace < (TInt64)KLargeFileSize)
 
   288         if(diskSpace < (TInt64)KLargeFileSize)
 
   274             {
 
   289             {
 
   275 		    TInt64 lastFileSize = diskSpace - KMinDiskSpace;
 
   290 		    TInt64 lastFileSize = diskSpace - KMinDiskSpace;
 
   276             fileSize = I64LOW(lastFileSize);
 
   291             fileSize = I64LOW(lastFileSize);
 
   277             }
 
   292             }
 
   278 		DoCreateLargeFileL(filePath, fileSize);
 
   293 		DoCreateLargeFileL(filePath, fileSize);
 
   279 		diskSpace = FreeDiskSpaceL();
 
   294 		diskSpace = FreeDiskSpaceL();
 
   280 		RDebug::Print(_L("----CreateLargeFileL, step %d, free space = %ld\n"), fileNo, diskSpace);
 
   295 		TheTest.Printf(_L("----CreateLargeFileL, step %d, free space = %ld\n"), fileNo, diskSpace);
 
   281 		}
 
   296 		}
 
   282 	diskSpace = FreeDiskSpaceL();
 
   297 	diskSpace = FreeDiskSpaceL();
 
   283 	RDebug::Print(_L("CreateLargeFileL: free space after = %ld\n"), diskSpace);
 
   298 	TheTest.Printf(_L("CreateLargeFileL: free space after = %ld\n"), diskSpace);
 
   284 	}
 
   299 	}
 
   285 
   300 
   286 //Reserves disk space for TheDbSession instance.
 
   301 //Reserves disk space for TheDbSession instance.
 
   287 //TheDbSession instance has to be connected already.
 
   302 //TheDbSession instance has to be connected already.
 
   288 static void ReserveDiskSpace()
 
   303 static void ReserveDiskSpace()
 
   289 	{
 
   304 	{
 
   290 	TInt err = TheDbSession.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   305 	TInt err = TheDbSession.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   291 	TEST2(err, KErrNone);
 
   306 	TEST2(err, KErrNone);
 
   292 	}
 
   307 	}
 
   293 
   308 
   294 //Frees already reserved disk space for TheDbSession instance.
 
   309 //Frees already reserved disk space for TheDbSession instance.
 
   295 //TheDbSession instance has to be connected already.
 
   310 //TheDbSession instance has to be connected already.
 
   296 static void FreeReservedSpace()
 
   311 static void FreeReservedSpace()
 
   297 	{
 
   312 	{
 
   298 	TheDbSession.FreeReservedSpace(KTestDrive);
 
   313 	TheDbSession.FreeReservedSpace(TheTestDrive);
 
   299 	}
 
   314 	}
 
   300 
   315 
   301 //Gets an access to the reserved disk space for TheDbSession instance.
 
   316 //Gets an access to the reserved disk space for TheDbSession instance.
 
   302 //TheDbSession instance has to be connected already.
 
   317 //TheDbSession instance has to be connected already.
 
   303 static void UnlockReservedSpace()
 
   318 static void UnlockReservedSpace()
 
   304 	{
 
   319 	{
 
   305 	TInt err = TheDbSession.GetReserveAccess(KTestDrive);
 
   320 	TInt err = TheDbSession.GetReserveAccess(TheTestDrive);
 
   306 	TEST2(err, KErrNone);
 
   321 	TEST2(err, KErrNone);
 
   307 	}
 
   322 	}
 
   308 
   323 
   309 //Releases the access to the reserved disk space.
 
   324 //Releases the access to the reserved disk space.
 
   310 //TheDbSession instance has to be connected already.
 
   325 //TheDbSession instance has to be connected already.
 
   311 static void LockReservedSpace()
 
   326 static void LockReservedSpace()
 
   312 	{
 
   327 	{
 
   313 	(void)TheDbSession.ReleaseReserveAccess(KTestDrive);
 
   328 	(void)TheDbSession.ReleaseReserveAccess(TheTestDrive);
 
   314 	}
 
   329 	}
 
   315 
   330 
   316 //Creates the test DBMS session
 
   331 //Creates the test DBMS session
 
   317 static void CreateTestDbSession()
 
   332 static void CreateTestDbSession()
 
   318 	{
 
   333 	{
 
   325 //TheDbSession instance has to be connected already.
 
   340 //TheDbSession instance has to be connected already.
 
   326 //TheFs.Connect() has to be called already.
 
   341 //TheFs.Connect() has to be called already.
 
   327 static void CreateTestDatabase(RDbs& aDbs, RDbNamedDatabase& aDb)
 
   342 static void CreateTestDatabase(RDbs& aDbs, RDbNamedDatabase& aDb)
 
   328 	{
 
   343 	{
 
   329 	//Create the test database.
 
   344 	//Create the test database.
 
   330 	TInt err = aDb.Replace(TheFs, KTestDatabase);
 
   345 	TInt err = aDb.Replace(TheFs, TheTestDatabase);
 
   331 	TEST2(err, KErrNone);
 
   346 	TEST2(err, KErrNone);
 
   332 	TheDb.Close();
 
   347 	TheDb.Close();
 
   333 	//Open it now using DBMS session (so, on DBMS server side), because we want to test
 
   348 	//Open it now using DBMS session (so, on DBMS server side), because we want to test
 
   334 	//server side RFs sessions - handling "out of disk space" situations.
 
   349 	//server side RFs sessions - handling "out of disk space" situations.
 
   335 	err = aDb.Open(aDbs, KTestDatabase);
 
   350 	err = aDb.Open(aDbs, TheTestDatabase);
 
   336 	TEST2(err, KErrNone);
 
   351 	TEST2(err, KErrNone);
 
   337 	}
 
   352 	}
 
   338 
   353 
   339 //Creates a test table
 
   354 //Creates a test table
 
   340 static void CreateTestTableL(RDbNamedDatabase& aDb)
 
   355 static void CreateTestTableL(RDbNamedDatabase& aDb)
 
   410 	RDbs dbs;
 
   425 	RDbs dbs;
 
   411 	CleanupClosePushL(dbs);
 
   426 	CleanupClosePushL(dbs);
 
   412 	LEAVE_IF_ERROR(dbs.Connect());
 
   427 	LEAVE_IF_ERROR(dbs.Connect());
 
   413 
   428 
   414 	//Reserve disk space
 
   429 	//Reserve disk space
 
   415 	TInt err = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   430 	TInt err = dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   416 	TEST2(err, KErrNone);
 
   431 	TEST2(err, KErrNone);
 
   417 
   432 
   418 	//An attempt to re-reserve it
 
   433 	//An attempt to re-reserve it
 
   419    	err = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   434    	err = dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   420 	TEST2(err, KErrInUse);
 
   435 	TEST2(err, KErrInUse);
 
   421 
   436 
   422 	//Get an access to the reserved disk space
 
   437 	//Get an access to the reserved disk space
 
   423 	err = dbs.GetReserveAccess(KTestDrive);
 
   438 	err = dbs.GetReserveAccess(TheTestDrive);
 
   424 	TEST2(err, KErrNone);
 
   439 	TEST2(err, KErrNone);
 
   425 
   440 
   426 	//An attempt to get an access to the reserved space twice.
 
   441 	//An attempt to get an access to the reserved space twice.
 
   427 	err = dbs.GetReserveAccess(KTestDrive);
 
   442 	err = dbs.GetReserveAccess(TheTestDrive);
 
   428 	TEST2(err, KErrInUse);
 
   443 	TEST2(err, KErrInUse);
 
   429 
   444 
   430 	//This call must fail, because it tries to get an access to the reserved space of
 
   445 	//This call must fail, because it tries to get an access to the reserved space of
 
   431 	//not the same drive, for which ReserveDriveSpace() was called.
 
   446 	//not the same drive, for which ReserveDriveSpace() was called.
 
   432 	err = dbs.GetReserveAccess(KTestDrive + 1);
 
   447 	err = dbs.GetReserveAccess(TheTestDrive + 1);
 
   433 	TEST(err != KErrNone);
 
   448 	TEST(err != KErrNone);
 
   434 
   449 
   435 	(void)dbs.ReleaseReserveAccess(KTestDrive);
 
   450 	(void)dbs.ReleaseReserveAccess(TheTestDrive);
 
   436 
   451 
   437 	//An attempt to release the reserved space twice. This call will panic in debug mode.
 
   452 	//An attempt to release the reserved space twice. This call will panic in debug mode.
 
   438 	//(void)dbs.ReleaseReserveAccess(KTestDrive);
 
   453 	//(void)dbs.ReleaseReserveAccess(TheTestDrive);
 
   439 
   454 
   440 	//Cancel reserving an additional disk space
 
   455 	//Cancel reserving an additional disk space
 
   441 	dbs.FreeReservedSpace(KTestDrive);
 
   456 	dbs.FreeReservedSpace(TheTestDrive);
 
   442 
   457 
   443 	//Cancel reserving an additional disk space twice
 
   458 	//Cancel reserving an additional disk space twice
 
   444     //This call will panic in debug mode.
 
   459     //This call will panic in debug mode.
 
   445 	//dbs.FreeReservedSpace(KTestDrive);
 
   460 	//dbs.FreeReservedSpace(TheTestDrive);
 
   446 
   461 
   447 	CleanupStack::PopAndDestroy(&dbs);
 
   462 	CleanupStack::PopAndDestroy(&dbs);
 
   448 	}
 
   463 	}
 
   449 
   464 
   450 /**
 
   465 /**
 
   458 @SYMREQ                 REQ0000
 
   473 @SYMREQ                 REQ0000
 
   459 */
 
   474 */
 
   460 static void TransactionTestL()
 
   475 static void TransactionTestL()
 
   461 	{
 
   476 	{
 
   462     TVolumeIOParamInfo volIoPrm;
 
   477     TVolumeIOParamInfo volIoPrm;
 
   463     TInt err = TheFs.VolumeIOParam(KTestDrive, volIoPrm);
 
   478     TInt err = TheFs.VolumeIOParam(TheTestDrive, volIoPrm);
 
   464     TEST2(err, KErrNone);
 
   479     TEST2(err, KErrNone);
 
   465     RDebug::Print(_L("--Drive %d. BlockSize=%d, ClusterSize=%d, RecReadBufSize=%d, RecWriteBufSize=%d\r\n"), KTestDrive, volIoPrm.iBlockSize, volIoPrm.iClusterSize, volIoPrm.iRecReadBufSize, volIoPrm.iRecWriteBufSize);
 
   480     TheTest.Printf(_L("--Drive %d. BlockSize=%d, ClusterSize=%d, RecReadBufSize=%d, RecWriteBufSize=%d\r\n"), TheTestDrive, volIoPrm.iBlockSize, volIoPrm.iClusterSize, volIoPrm.iRecReadBufSize, volIoPrm.iRecWriteBufSize);
 
   466     /////////////////////////////////////////////////////////
 
   481     /////////////////////////////////////////////////////////
 
   467 	CreateTestDbSession();
 
   482 	CreateTestDbSession();
 
   468     //Rserve disk space
 
   483     //Rserve disk space
 
   469 	ReserveDiskSpace();
 
   484 	ReserveDiskSpace();
 
   470     //Create test database and table. Add some test data to them.
 
   485     //Create test database and table. Add some test data to them.
 
   471 	CreateTestDatabase(TheDbSession, TheDb);
 
   486 	CreateTestDatabase(TheDbSession, TheDb);
 
   472 	CreateTestTableL(TheDb);
 
   487 	CreateTestTableL(TheDb);
 
   473 	AddTestDataL(TheDb);
 
   488 	AddTestDataL(TheDb);
 
   474     RDebug::Print(_L("--Simulate an \"out of disk space\" situation with creating a very large data file, which occupies almost the all the available disk space.\r\n"));
 
   489 	TheTest.Printf(_L("--Simulate an \"out of disk space\" situation with creating a very large data file, which occupies almost the all the available disk space.\r\n"));
 
   475 	CreateLargeFileL();
 
   490 	CreateLargeFileL();
 
   476     RDebug::Print(_L("--Attempt to delete test data records. The transaction must fail, because of \"out of disk space\".\r\n"));
 
   491 	TheTest.Printf(_L("--Attempt to delete test data records. The transaction must fail, because of \"out of disk space\".\r\n"));
 
   477     TInt64 diskSpace = FreeDiskSpaceL();
 
   492     TInt64 diskSpace = FreeDiskSpaceL();
 
   478 	RDebug::Print(_L("--Attempt to delete test data records. Free disk space = %ld\n"), diskSpace);
 
   493     TheTest.Printf(_L("--Attempt to delete test data records. Free disk space = %ld\n"), diskSpace);
 
   479 	TRAP(err, DeleteRecordsL());
 
   494 	TRAP(err, DeleteRecordsL());
 
   480 	RDebug::Print(_L("--DeleteRecordsL() returned %d error\r\n"), err);
 
   495 	TheTest.Printf(_L("--DeleteRecordsL() returned %d error\r\n"), err);
 
   481 	TEST(err != KErrNone);
 
   496 	TEST(err != KErrNone);
 
   482     RDebug::Print(_L("--The attempt failed with err=%d. Get an access to the reserved disk space.\r\n"), err);
 
   497 	TheTest.Printf(_L("--The attempt failed with err=%d. Get an access to the reserved disk space.\r\n"), err);
 
   483     UnlockReservedSpace();
 
   498     UnlockReservedSpace();
 
   484 	RDebug::Print(_L("--Try again with getting an access to the reserved disk space.\n"));
 
   499     TheTest.Printf(_L("--Try again with getting an access to the reserved disk space.\n"));
 
   485     diskSpace = FreeDiskSpaceL();
 
   500     diskSpace = FreeDiskSpaceL();
 
   486     RDebug::Print(_L("After GetReserveAccess(), free disk space = %ld\r\n"), diskSpace);
 
   501     TheTest.Printf(_L("After GetReserveAccess(), free disk space = %ld\r\n"), diskSpace);
 
   487 	DeleteRecordsL();
 
   502 	DeleteRecordsL();
 
   488 	RDebug::Print(_L("--\"Delete\" transaction was completed successfully.\n"));
 
   503 	TheTest.Printf(_L("--\"Delete\" transaction was completed successfully.\n"));
 
   489     //Free the resources, used in the test
 
   504     //Free the resources, used in the test
 
   490 	DeleteLargeDataFiles();
 
   505 	DeleteLargeDataFiles();
 
   491 	LockReservedSpace();
 
   506 	LockReservedSpace();
 
   492     FreeReservedSpace();
 
   507     FreeReservedSpace();
 
   493 	}
 
   508 	}
 
   512     CleanupClosePushL(dbSess1);
 
   527     CleanupClosePushL(dbSess1);
 
   513     LEAVE_IF_ERROR(dbSess1.Connect());
 
   528     LEAVE_IF_ERROR(dbSess1.Connect());
 
   514 
   529 
   515     RDbNamedDatabase db1;
 
   530     RDbNamedDatabase db1;
 
   516     CleanupClosePushL(db1);
 
   531     CleanupClosePushL(db1);
 
   517 	TInt err = db1.Open(dbSess1, KTestDatabase);
 
   532 	TInt err = db1.Open(dbSess1, TheTestDatabase);
 
   518 	TEST2(err, KErrNone);
 
   533 	TEST2(err, KErrNone);
 
   519 
   534 
   520 	RDbTable tbl1;
 
   535 	RDbTable tbl1;
 
   521 	CleanupClosePushL(tbl1);
 
   536 	CleanupClosePushL(tbl1);
 
   522 	TEST2(tbl1.Open(db1, KTestTableName, RDbRowSet::EUpdatable), KErrNone);
 
   537 	TEST2(tbl1.Open(db1, KTestTableName, RDbRowSet::EUpdatable), KErrNone);
 
   526     CleanupClosePushL(dbSess2);
 
   541     CleanupClosePushL(dbSess2);
 
   527     LEAVE_IF_ERROR(dbSess2.Connect());
 
   542     LEAVE_IF_ERROR(dbSess2.Connect());
 
   528 
   543 
   529     RDbNamedDatabase db2;
 
   544     RDbNamedDatabase db2;
 
   530     CleanupClosePushL(db2);
 
   545     CleanupClosePushL(db2);
 
   531 	err = db2.Open(dbSess2, KTestDatabase);
 
   546 	err = db2.Open(dbSess2, TheTestDatabase);
 
   532 	TEST2(err, KErrNone);
 
   547 	TEST2(err, KErrNone);
 
   533 
   548 
   534 	RDbTable tbl2;
 
   549 	RDbTable tbl2;
 
   535 	CleanupClosePushL(tbl2);
 
   550 	CleanupClosePushL(tbl2);
 
   536 	TEST2(tbl2.Open(db2, KTestTableName, RDbRowSet::EUpdatable), KErrNone);
 
   551 	TEST2(tbl2.Open(db2, KTestTableName, RDbRowSet::EUpdatable), KErrNone);
 
   583     RDbs dbSess2;
 
   598     RDbs dbSess2;
 
   584     CleanupClosePushL(dbSess2);
 
   599     CleanupClosePushL(dbSess2);
 
   585     LEAVE_IF_ERROR(dbSess2.Connect());
 
   600     LEAVE_IF_ERROR(dbSess2.Connect());
 
   586 
   601 
   587     //Play with "ReserveDriveSpace" on both sessions
 
   602     //Play with "ReserveDriveSpace" on both sessions
 
   588     TInt err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   603     TInt err = dbSess1.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   589     TEST2(err, KErrNone);
 
   604     TEST2(err, KErrNone);
 
   590     err = dbSess2.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   605     err = dbSess2.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   591     TEST2(err, KErrNone);
 
   606     TEST2(err, KErrNone);
 
   592     dbSess2.FreeReservedSpace(KTestDrive);
 
   607     dbSess2.FreeReservedSpace(TheTestDrive);
 
   593     err = dbSess2.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   608     err = dbSess2.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   594     TEST2(err, KErrNone);
 
   609     TEST2(err, KErrNone);
 
   595 
   610 
   596     //Get an access to the reserved space through session 2
 
   611     //Get an access to the reserved space through session 2
 
   597 	err = dbSess2.GetReserveAccess(KTestDrive);
 
   612 	err = dbSess2.GetReserveAccess(TheTestDrive);
 
   598     TEST2(err, KErrNone);
 
   613     TEST2(err, KErrNone);
 
   599     //Free/re-reserve disk space for session 1.
 
   614     //Free/re-reserve disk space for session 1.
 
   600     dbSess1.FreeReservedSpace(KTestDrive);
 
   615     dbSess1.FreeReservedSpace(TheTestDrive);
 
   601     err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   616     err = dbSess1.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   602     TEST2(err, KErrNone);
 
   617     TEST2(err, KErrNone);
 
   603 
   618 
   604     //Create session4
 
   619     //Create session4
 
   605     RDbs dbSess4;
 
   620     RDbs dbSess4;
 
   606     CleanupClosePushL(dbSess4);
 
   621     CleanupClosePushL(dbSess4);
 
   607     LEAVE_IF_ERROR(dbSess4.Connect());
 
   622     LEAVE_IF_ERROR(dbSess4.Connect());
 
   608 
   623 
   609     //Try to reserve space for session 4.
 
   624     //Try to reserve space for session 4.
 
   610     err = dbSess4.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   625     err = dbSess4.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   611     TEST2(err, KErrNone);
 
   626     TEST2(err, KErrNone);
 
   612 
   627 
   613     //Create session3
 
   628     //Create session3
 
   614     RDbs dbSess3;
 
   629     RDbs dbSess3;
 
   615     CleanupClosePushL(dbSess3);
 
   630     CleanupClosePushL(dbSess3);
 
   616     LEAVE_IF_ERROR(dbSess3.Connect());
 
   631     LEAVE_IF_ERROR(dbSess3.Connect());
 
   617     //Try to reserve space for session 3.
 
   632     //Try to reserve space for session 3.
 
   618     err = dbSess3.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   633     err = dbSess3.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   619     TEST2(err, KErrNone);
 
   634     TEST2(err, KErrNone);
 
   620 
   635 
   621     //Release and free session 2 access to the reserved space.
 
   636     //Release and free session 2 access to the reserved space.
 
   622     (void)dbSess2.ReleaseReserveAccess(KTestDrive);
 
   637     (void)dbSess2.ReleaseReserveAccess(TheTestDrive);
 
   623     dbSess2.FreeReservedSpace(KTestDrive);
 
   638     dbSess2.FreeReservedSpace(TheTestDrive);
 
   624 
   639 
   625     dbSess3.FreeReservedSpace(KTestDrive);
 
   640     dbSess3.FreeReservedSpace(TheTestDrive);
 
   626     CleanupStack::PopAndDestroy(&dbSess3);
 
   641     CleanupStack::PopAndDestroy(&dbSess3);
 
   627 
   642 
   628     dbSess4.FreeReservedSpace(KTestDrive);
 
   643     dbSess4.FreeReservedSpace(TheTestDrive);
 
   629     CleanupStack::PopAndDestroy(&dbSess4);
 
   644     CleanupStack::PopAndDestroy(&dbSess4);
 
   630 
   645 
   631     //Get an access to the reserved space through session 2.
 
   646     //Get an access to the reserved space through session 2.
 
   632     //But it was freed, so the call will fail.
 
   647     //But it was freed, so the call will fail.
 
   633 	err = dbSess2.GetReserveAccess(KTestDrive);
 
   648 	err = dbSess2.GetReserveAccess(TheTestDrive);
 
   634     TEST(err != KErrNone);
 
   649     TEST(err != KErrNone);
 
   635 
   650 
   636     //Free/re-reserve disk space for session 1.
 
   651     //Free/re-reserve disk space for session 1.
 
   637     dbSess1.FreeReservedSpace(KTestDrive);
 
   652     dbSess1.FreeReservedSpace(TheTestDrive);
 
   638     err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   653     err = dbSess1.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   639     TEST2(err, KErrNone);
 
   654     TEST2(err, KErrNone);
 
   640 
   655 
   641     //Grant/release the access to the reserved space for session 1.
 
   656     //Grant/release the access to the reserved space for session 1.
 
   642 	err = dbSess1.GetReserveAccess(KTestDrive);
 
   657 	err = dbSess1.GetReserveAccess(TheTestDrive);
 
   643     TEST2(err, KErrNone);
 
   658     TEST2(err, KErrNone);
 
   644     (void)dbSess1.ReleaseReserveAccess(KTestDrive);
 
   659     (void)dbSess1.ReleaseReserveAccess(TheTestDrive);
 
   645 
   660 
   646     //Grant an access to the reserved space for session 2.
 
   661     //Grant an access to the reserved space for session 2.
 
   647     //The call will fail because there is no reserved disk space for session 2.
 
   662     //The call will fail because there is no reserved disk space for session 2.
 
   648 	err = dbSess2.GetReserveAccess(KTestDrive);
 
   663 	err = dbSess2.GetReserveAccess(TheTestDrive);
 
   649     TEST(err != KErrNone);
 
   664     TEST(err != KErrNone);
 
   650 
   665 
   651     //Free the reserved space - session 1
 
   666     //Free the reserved space - session 1
 
   652     dbSess1.FreeReservedSpace(KTestDrive);
 
   667     dbSess1.FreeReservedSpace(TheTestDrive);
 
   653 
   668 
   654     CleanupStack::PopAndDestroy(&dbSess2);
 
   669     CleanupStack::PopAndDestroy(&dbSess2);
 
   655     CleanupStack::PopAndDestroy(&dbSess1);
 
   670     CleanupStack::PopAndDestroy(&dbSess1);
 
   656     }
 
   671     }
 
   657 
   672 
   668     RDbs dbs;
 
   683     RDbs dbs;
 
   669     TEST2(dbs.Connect(), KErrNone);
 
   684     TEST2(dbs.Connect(), KErrNone);
 
   670 	dbs.ResourceMark();
 
   685 	dbs.ResourceMark();
 
   671 	for(TInt count=1;;++count)
 
   686 	for(TInt count=1;;++count)
 
   672 		{
 
   687 		{
 
   673         RDebug::Print(_L("OOMTest1. Count=%d\n"), count);
 
   688 		TheTest.Printf(_L("OOMTest1. Count=%d\n"), count);
 
   674 		dbs.SetHeapFailure(RHeap::EFailNext, count);
 
   689 		dbs.SetHeapFailure(RHeap::EFailNext, count);
 
   675 
   690 
   676 		TInt ret = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
 
   691 		TInt ret = dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
   677 
   692 
   678 		if(ret == KErrNoMemory)
 
   693 		if(ret == KErrNoMemory)
 
   679 			{
 
   694 			{
 
   680 	        dbs.ResourceCheck();
 
   695 	        dbs.ResourceCheck();
 
   681 			}
 
   696 			}
 
   682 		else if(ret == KErrNone)
 
   697 		else if(ret == KErrNone)
 
   683 			{
 
   698 			{
 
   684 			dbs.FreeReservedSpace(KTestDrive);
 
   699 			dbs.FreeReservedSpace(TheTestDrive);
 
   685 			break;
 
   700 			break;
 
   686 			}
 
   701 			}
 
   687 		else
 
   702 		else
 
   688 			{
 
   703 			{
 
   689 			TEST2(ret, KErrNone);
 
   704 			TEST2(ret, KErrNone);
 
   704 */
 
   719 */
 
   705 static void OOMTest2()
 
   720 static void OOMTest2()
 
   706     {
 
   721     {
 
   707     RDbs dbs;
 
   722     RDbs dbs;
 
   708     TEST2(dbs.Connect(), KErrNone);
 
   723     TEST2(dbs.Connect(), KErrNone);
 
   709 	TEST2(dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize), KErrNone);
 
   724 	TEST2(dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize), KErrNone);
 
   710 	dbs.ResourceMark();
 
   725 	dbs.ResourceMark();
 
   711 	for(TInt count=1;;++count)
 
   726 	for(TInt count=1;;++count)
 
   712 		{
 
   727 		{
 
   713         RDebug::Print(_L("OOMTest2. Count=%d\n"), count);
 
   728 		TheTest.Printf(_L("OOMTest2. Count=%d\n"), count);
 
   714 		dbs.SetHeapFailure(RHeap::EFailNext, count);
 
   729 		dbs.SetHeapFailure(RHeap::EFailNext, count);
 
   715 
   730 
   716 		TInt ret = dbs.GetReserveAccess(KTestDrive);
 
   731 		TInt ret = dbs.GetReserveAccess(TheTestDrive);
 
   717 
   732 
   718 		if(ret == KErrNoMemory)
 
   733 		if(ret == KErrNoMemory)
 
   719 			{
 
   734 			{
 
   720 	        dbs.ResourceCheck();
 
   735 	        dbs.ResourceCheck();
 
   721 			}
 
   736 			}
 
   722 		else if(ret == KErrNone)
 
   737 		else if(ret == KErrNone)
 
   723 			{
 
   738 			{
 
   724 			(void)dbs.ReleaseReserveAccess(KTestDrive);
 
   739 			(void)dbs.ReleaseReserveAccess(TheTestDrive);
 
   725 			break;
 
   740 			break;
 
   726 			}
 
   741 			}
 
   727 		else
 
   742 		else
 
   728 			{
 
   743 			{
 
   729 			TEST2(ret, KErrNone);
 
   744 			TEST2(ret, KErrNone);
 
   730 			}
 
   745 			}
 
   731 		}
 
   746 		}
 
   732 
   747 
   733 	dbs.FreeReservedSpace(KTestDrive);
 
   748 	dbs.FreeReservedSpace(TheTestDrive);
 
   734     dbs.SetHeapFailure(RHeap::ENone, 0);
 
   749     dbs.SetHeapFailure(RHeap::ENone, 0);
 
   735     dbs.Close();
 
   750     dbs.Close();
 
   736     }
 
   751     }
 
   737 
   752 
   738 
   753 
   741 	{
 
   756 	{
 
   742 	User::SetJustInTime(EFalse);	// disable debugger panic handling
 
   757 	User::SetJustInTime(EFalse);	// disable debugger panic handling
 
   743 	//Create DBMS session. Reserve drive space.
 
   758 	//Create DBMS session. Reserve drive space.
 
   744     RDbs dbs;
 
   759     RDbs dbs;
 
   745     TEST2(dbs.Connect(), KErrNone);
 
   760     TEST2(dbs.Connect(), KErrNone);
 
   746 	TEST2(dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize), KErrNone);
 
   761 	TEST2(dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize), KErrNone);
 
   747 	//Panic thread. See DBMS server behaviour - will it panic or not?
 
   762 	//Panic thread. See DBMS server behaviour - will it panic or not?
 
   748 	//If DBMS server panics in _DEBUG mode - DEF057265 is not properly fixed.
 
   763 	//If DBMS server panics in _DEBUG mode - DEF057265 is not properly fixed.
 
   749 	User::Panic(_L("Simulate DBMS client failuer"), 0);
 
   764 	User::Panic(_L("Simulate DBMS client failuer"), 0);
 
   750 	return KErrNone;
 
   765 	return KErrNone;
 
   751 	}
 
   766 	}
 
   811 	__UHEAP_MARK;
 
   826 	__UHEAP_MARK;
 
   812 
   827 
   813 	CTrapCleanup* trapCleanup = CTrapCleanup::New();
 
   828 	CTrapCleanup* trapCleanup = CTrapCleanup::New();
 
   814 	TEST(trapCleanup != NULL);
 
   829 	TEST(trapCleanup != NULL);
 
   815 
   830 
       
   831 	TheTestDrive = KTestDrive;
 
       
   832 	TheTestDatabase.Copy(KTestDatabase);
 
       
   833 	TheLargeFileName.Copy(KLargeFileName);
 
       
   834 	
   816 	DeleteLargeDataFiles();
 
   835 	DeleteLargeDataFiles();
 
   817 
   836 
   818 	TInt err = TheFs.Connect();
 
   837 	TInt err = TheFs.Connect();
 
   819 	TEST2(err, KErrNone);
 
   838 	TEST2(err, KErrNone);
 
   820 	SetupTestDirectory();
 
   839 	SetupTestDirectory();
FCL/sf/os/persistentdata