63 |
63 |
64 #endif |
64 #endif |
65 |
65 |
66 _LIT8(KDatabasePageSizeConfig, "page_size=1024"); |
66 _LIT8(KDatabasePageSizeConfig, "page_size=1024"); |
67 |
67 |
|
68 //The drive that will be used in case if the original drive, where KTestDir is supposed to be created, is not present. |
|
69 const TInt KTestDrive2 = EDriveC; |
|
70 _LIT(KTestDir2, "c:\\test\\"); |
|
71 _LIT(KTestDatabase2, "c:\\test\\t_sql_ood.db"); |
|
72 _LIT(KLargeFileName2, "c:\\test\\DeleteMe"); |
|
73 |
68 const TInt KMaxTestRecordsCount = 350; |
74 const TInt KMaxTestRecordsCount = 350; |
69 TInt TestRecordsCount = 0; |
75 TInt TestRecordsCount = 0; |
|
76 |
|
77 |
|
78 TInt TheTestDrive = -1; |
|
79 TFileName TheTestDir; |
|
80 TFileName TheTestDatabase; |
|
81 TFileName TheLargeFileName; |
70 |
82 |
71 /////////////////////////////////////////////////////////////////////////////////////// |
83 /////////////////////////////////////////////////////////////////////////////////////// |
72 |
84 |
73 //Assemblesd a file name from "aFileName" and "aFileNumber" parameters and places the resulting string in "aResultPath". |
85 //Assemblesd a file name from "aFileName" and "aFileNumber" parameters and places the resulting string in "aResultPath". |
74 void AssembleLargeFileName(const TDesC& aFileName, TInt aFileNumber, TDes& aResultPath) |
86 void AssembleLargeFileName(const TDesC& aFileName, TInt aFileNumber, TDes& aResultPath) |
83 TInt err = KErrNone; |
95 TInt err = KErrNone; |
84 TInt i = -1; |
96 TInt i = -1; |
85 while(err == KErrNone) |
97 while(err == KErrNone) |
86 { |
98 { |
87 TBuf<KMaxFileName> filePath; |
99 TBuf<KMaxFileName> filePath; |
88 ::AssembleLargeFileName(KLargeFileName, ++i, filePath); |
100 ::AssembleLargeFileName(TheLargeFileName, ++i, filePath); |
89 err = TheFs.Delete(filePath); |
101 err = TheFs.Delete(filePath); |
90 } |
102 } |
91 } |
103 } |
92 |
104 |
93 //Deletes all created test files. |
105 //Deletes all created test files. |
94 void DeleteTestFiles() |
106 void DeleteTestFiles() |
95 { |
107 { |
96 DeleteLargeDataFiles(); |
108 DeleteLargeDataFiles(); |
97 (void)RSqlDatabase::Delete(KTestDatabase); |
109 (void)RSqlDatabase::Delete(TheTestDatabase); |
98 } |
110 } |
99 |
111 |
100 /////////////////////////////////////////////////////////////////////////////////////// |
112 /////////////////////////////////////////////////////////////////////////////////////// |
101 /////////////////////////////////////////////////////////////////////////////////////// |
113 /////////////////////////////////////////////////////////////////////////////////////// |
102 //Test macros and functions |
114 //Test macros and functions |
103 void Check1(TInt aValue, TInt aLine) |
115 void Check1(TInt aValue, TInt aLine) |
104 { |
116 { |
105 if(!aValue) |
117 if(!aValue) |
106 { |
118 { |
107 DeleteTestFiles(); |
119 DeleteTestFiles(); |
108 RDebug::Print(_L("*** Line %d\r\n"), aLine); |
120 TheTest.Printf(_L("*** Line %d\r\n"), aLine); |
109 TheTest(EFalse, aLine); |
121 TheTest(EFalse, aLine); |
110 } |
122 } |
111 } |
123 } |
112 void Check2(TInt aValue, TInt aExpected, TInt aLine) |
124 void Check2(TInt aValue, TInt aExpected, TInt aLine) |
113 { |
125 { |
114 if(aValue != aExpected) |
126 if(aValue != aExpected) |
115 { |
127 { |
116 DeleteTestFiles(); |
128 DeleteTestFiles(); |
117 RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue); |
129 TheTest.Printf(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue); |
118 TheTest(EFalse, aLine); |
130 TheTest(EFalse, aLine); |
119 } |
131 } |
120 } |
132 } |
121 #define TEST(arg) ::Check1((arg), __LINE__) |
133 #define TEST(arg) ::Check1((arg), __LINE__) |
122 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__) |
134 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__) |
127 void CreateTestEnv() |
139 void CreateTestEnv() |
128 { |
140 { |
129 TInt err = TheFs.Connect(); |
141 TInt err = TheFs.Connect(); |
130 TEST2(err, KErrNone); |
142 TEST2(err, KErrNone); |
131 |
143 |
132 err = TheFs.MkDir(KTestDir); |
144 err = TheFs.MkDir(TheTestDir); |
133 if(err != KErrNone) |
145 if(err != KErrNone && err != KErrAlreadyExists) |
134 { |
146 { |
135 RDebug::Print(_L("*** CreateTestEnv(), RFs::MkDir(), err=%d\r\n"), err); |
147 TheTest.Printf(_L("*** CreateTestEnv(), RFs::MkDir(), dir=%S, err=%d.\r\nNext attempt with %S.\r\n"), &TheTestDir, err, &KTestDir2); |
|
148 TheTestDrive = KTestDrive2; |
|
149 TheTestDir.Copy(KTestDir2); |
|
150 TheTestDatabase.Copy(KTestDatabase2); |
|
151 TheLargeFileName.Copy(KLargeFileName2); |
|
152 err = TheFs.MkDir(TheTestDir); |
136 } |
153 } |
|
154 TheTest.Printf(_L("*** CreateTestEnv(), RFs::MkDir(), dir=%S, err=%d."), &TheTestDir, err); |
137 TEST(err == KErrNone || err == KErrAlreadyExists); |
155 TEST(err == KErrNone || err == KErrAlreadyExists); |
138 } |
156 } |
139 |
157 |
140 //Creates one or more large files with the total size near to the size of the available disk space. |
158 //Creates one or more large files with the total size near to the size of the available disk space. |
141 //The idea is to cause an "out of disk space" condition. |
159 //The idea is to cause an "out of disk space" condition. |
142 void FillLargeDataFile(RFile& aFile, TInt aSize) |
160 void FillLargeDataFile(RFile& aFile, TInt aSize) |
143 { |
161 { |
144 TInt err = KErrDiskFull; |
162 TInt err = KErrDiskFull; |
|
163 TheTest.Printf(_L("FillLargeDataFile-1\r\n")); |
145 while(err == KErrDiskFull) |
164 while(err == KErrDiskFull) |
146 { |
165 { |
147 err = aFile.SetSize(aSize); |
166 err = aFile.SetSize(aSize); |
|
167 TheTest.Printf(_L("FillLargeDataFile-2 err=%d aSize=%d\r\n"), err, aSize); |
148 aSize -= 100; |
168 aSize -= 100; |
149 if(aSize <= 0) |
169 if(aSize <= 0) |
150 { |
170 { |
151 break; |
171 break; |
152 } |
172 } |
156 |
176 |
157 //Gets and returns the available disk space of the tested drive. |
177 //Gets and returns the available disk space of the tested drive. |
158 TInt64 FreeDiskSpace() |
178 TInt64 FreeDiskSpace() |
159 { |
179 { |
160 TVolumeInfo volInfoBefore; |
180 TVolumeInfo volInfoBefore; |
161 TInt err = TheFs.Volume(volInfoBefore, KTestDrive); |
181 TInt err = TheFs.Volume(volInfoBefore, TheTestDrive); |
162 TEST2(err, KErrNone); |
182 TEST2(err, KErrNone); |
163 return volInfoBefore.iFree; |
183 return volInfoBefore.iFree; |
164 } |
184 } |
165 |
185 |
166 //Creates a large data file with aSize size (in bytes). |
186 //Creates a large data file with aSize size (in bytes). |
167 void DoCreateLargeFile(const TDesC& aPath, TInt aSize) |
187 void DoCreateLargeFile(const TDesC& aPath, TInt aSize) |
168 { |
188 { |
|
189 TheTest.Printf(_L("DoCreateLargeFile, aPath=%S, aSize=%d\r\n"), &aPath, aSize/1000); |
169 RFile file; |
190 RFile file; |
170 TInt err = file.Replace(TheFs, aPath, EFileRead | EFileWrite); |
191 TInt err = file.Replace(TheFs, aPath, EFileRead | EFileWrite); |
|
192 TheTest.Printf(_L("DoCreateLargeFile, err=%d\r\n"), err); |
171 TEST2(err, KErrNone); |
193 TEST2(err, KErrNone); |
172 FillLargeDataFile(file, aSize); |
194 FillLargeDataFile(file, aSize); |
173 err = file.Flush(); |
195 err = file.Flush(); |
|
196 TheTest.Printf(_L("DoCreateLargeFile, flush err=%d\r\n"), err); |
174 TEST2(err, KErrNone); |
197 TEST2(err, KErrNone); |
175 file.Close(); |
198 file.Close(); |
|
199 TheTest.Printf(_L("DoCreateLargeFile, close\r\n")); |
176 } |
200 } |
177 |
201 |
178 //Creates enough number of large data files to fill the available disk space. |
202 //Creates enough number of large data files to fill the available disk space. |
179 void CreateLargeFile() |
203 void CreateLargeFile() |
180 { |
204 { |
181 TInt fileNo = 0; |
205 TInt fileNo = 0; |
182 const TInt KLargeFileSize = 1000000000; |
206 const TInt KLargeFileSize = 1000000000; |
183 TInt64 diskSpace = ::FreeDiskSpace(); |
207 TInt64 diskSpace = ::FreeDiskSpace(); |
184 RDebug::Print(_L("CreateLargeFile: free space before = %ld\r\n"), diskSpace); |
208 TheTest.Printf(_L("CreateLargeFile: free space before = %ld\r\n"), diskSpace); |
185 TBuf<KMaxFileName> filePath; |
209 TBuf<KMaxFileName> filePath; |
186 while(diskSpace > KLargeFileSize) |
210 while(diskSpace > KLargeFileSize) |
187 { |
211 { |
188 AssembleLargeFileName(KLargeFileName, fileNo++, filePath); |
212 AssembleLargeFileName(TheLargeFileName, fileNo++, filePath); |
189 DoCreateLargeFile(filePath, KLargeFileSize); |
213 DoCreateLargeFile(filePath, KLargeFileSize); |
190 diskSpace = ::FreeDiskSpace(); |
214 diskSpace = ::FreeDiskSpace(); |
191 RDebug::Print(_L("----CreateLargeFile, step %d, free space = %ld\r\n"), fileNo, diskSpace); |
215 TheTest.Printf(_L("----CreateLargeFile, step %d, free space = %ld\r\n"), fileNo, diskSpace); |
192 } |
216 } |
193 //Reserve almost all disk space, except a small amount - 200 bytes. |
217 //Reserve almost all disk space, except a small amount - 200 bytes. |
194 if(diskSpace > 0) |
218 if(diskSpace > 0) |
195 { |
219 { |
196 ::AssembleLargeFileName(KLargeFileName, fileNo++, filePath); |
220 ::AssembleLargeFileName(TheLargeFileName, fileNo++, filePath); |
197 const TInt64 KSpaceLeft = 200; |
221 const TInt64 KSpaceLeft = 200; |
198 TInt64 lastFileSize = diskSpace - KSpaceLeft; |
222 TInt64 lastFileSize = diskSpace - KSpaceLeft; |
199 TInt lastFileSize32 = I64LOW(lastFileSize); |
223 TInt lastFileSize32 = I64LOW(lastFileSize); |
200 RDebug::Print(_L("----file size32 = %d\r\n"), lastFileSize32); |
224 TheTest.Printf(_L("----file size32 = %d\r\n"), lastFileSize32); |
201 ::DoCreateLargeFile(filePath, lastFileSize32); |
225 ::DoCreateLargeFile(filePath, lastFileSize32); |
202 RDebug::Print(_L("----CreateLargeFile, last step (%d), file size = %ld\r\n"), fileNo, lastFileSize); |
226 TheTest.Printf(_L("----CreateLargeFile, last step (%d), file size = %ld\r\n"), fileNo, lastFileSize); |
203 } |
227 } |
204 diskSpace = ::FreeDiskSpace(); |
228 diskSpace = ::FreeDiskSpace(); |
205 RDebug::Print(_L("CreateLargeFile: free space after = %ld\r\n"), diskSpace); |
229 TheTest.Printf(_L("CreateLargeFile: free space after = %ld\r\n"), diskSpace); |
206 } |
230 } |
207 |
231 |
208 |
232 |
209 // Number of bytes in the default journal header size. |
233 // Number of bytes in the default journal header size. |
210 const TInt KJournalHeaderSize = 0x200; |
234 const TInt KJournalHeaderSize = 0x200; |
229 TBuf<200> sql; |
253 TBuf<200> sql; |
230 sql.Copy(_L("PRAGMA page_size")); |
254 sql.Copy(_L("PRAGMA page_size")); |
231 TSqlScalarFullSelectQuery q(aDb); |
255 TSqlScalarFullSelectQuery q(aDb); |
232 TInt pageSize = 0; |
256 TInt pageSize = 0; |
233 TRAP(err, pageSize = q.SelectIntL(sql);); |
257 TRAP(err, pageSize = q.SelectIntL(sql);); |
234 //RDebug::Print(_L("Error %d Page Size %d"),err,pageSize); |
258 //TheTest.Printf(_L("Error %d Page Size %d"),err,pageSize); |
235 TEST2(err, KErrNone); |
259 TEST2(err, KErrNone); |
236 TEST(pageSize > 0); |
260 TEST(pageSize > 0); |
237 //RDebug::Print(_L("Page Size %d"),pageSize); |
261 //TheTest.Printf(_L("Page Size %d"),pageSize); |
238 |
262 |
239 // |
263 // |
240 // Find the sector size of this media |
264 // Find the sector size of this media |
241 // |
265 // |
242 TDriveInfo driveInfo; |
266 TDriveInfo driveInfo; |
243 err = TheFs.Drive(driveInfo, KTestDrive); |
267 err = TheFs.Drive(driveInfo, TheTestDrive); |
244 TEST2(err, KErrNone); |
268 TEST2(err, KErrNone); |
245 TVolumeIOParamInfo volumeInfo; |
269 TVolumeIOParamInfo volumeInfo; |
246 err = TheFs.VolumeIOParam(KTestDrive, volumeInfo); |
270 err = TheFs.VolumeIOParam(TheTestDrive, volumeInfo); |
247 TEST2(err, KErrNone); |
271 TEST2(err, KErrNone); |
248 TInt sectorSize = volumeInfo.iBlockSize; |
272 TInt sectorSize = volumeInfo.iBlockSize; |
249 //RDebug::Print(_L("Sector Size %d"),sectorSize); |
273 //TheTest.Printf(_L("Sector Size %d"),sectorSize); |
250 |
274 |
251 TInt journalHeaderSize = Max(sectorSize, KJournalHeaderSize); |
275 TInt journalHeaderSize = Max(sectorSize, KJournalHeaderSize); |
252 //RDebug::Print(_L("Journal Header Size %d"),journalHeaderSize); |
276 //TheTest.Printf(_L("Journal Header Size %d"),journalHeaderSize); |
253 |
277 |
254 // |
278 // |
255 // Keep adding to database until it is a size such that all the data can still be deleted within the reserved disk space size. |
279 // Keep adding to database until it is a size such that all the data can still be deleted within the reserved disk space size. |
256 // Do this piece-wise not in a transaction. |
280 // Do this piece-wise not in a transaction. |
257 // |
281 // |
263 TEST2(err, 1); |
287 TEST2(err, 1); |
264 |
288 |
265 TInt size = aDb.Size(); |
289 TInt size = aDb.Size(); |
266 TInt numberOfPages = size/pageSize; |
290 TInt numberOfPages = size/pageSize; |
267 TInt predictedJournalSize = journalHeaderSize + numberOfPages * (pageSize + KJournalPageOverhead); |
291 TInt predictedJournalSize = journalHeaderSize + numberOfPages * (pageSize + KJournalPageOverhead); |
268 //RDebug::Print(_L("Size %d, Pages %d, predictedJournalSize %d"),size, numberOfPages, predictedJournalSize); |
292 //TheTest.Printf(_L("Size %d, Pages %d, predictedJournalSize %d"),size, numberOfPages, predictedJournalSize); |
269 |
293 |
270 // Will another page take us over the limit ? |
294 // Will another page take us over the limit ? |
271 if ((predictedJournalSize + (pageSize + KJournalPageOverhead)) >= (KReserveDriveSpaceAmount)) |
295 if ((predictedJournalSize + (pageSize + KJournalPageOverhead)) >= (KReserveDriveSpaceAmount)) |
272 { |
296 { |
273 break; |
297 break; |
274 } |
298 } |
275 } |
299 } |
276 TestRecordsCount = i + 1; |
300 TestRecordsCount = i + 1; |
277 |
301 |
278 //RDebug::Print(_L("TestRecordsCount %d"),TestRecordsCount); |
302 //TheTest.Printf(_L("TestRecordsCount %d"),TestRecordsCount); |
279 |
303 |
280 } |
304 } |
281 |
305 |
282 //Tries to delete test database records |
306 //Tries to delete test database records |
283 TInt DeleteTestRecords(RSqlDatabase& aDb) |
307 TInt DeleteTestRecords(RSqlDatabase& aDb) |
305 //RSqlDatabase::ReleaseReserveAccess() methods and checks the return values. |
329 //RSqlDatabase::ReleaseReserveAccess() methods and checks the return values. |
306 //It might be usefull for debugging in case if something gets wrong. |
330 //It might be usefull for debugging in case if something gets wrong. |
307 void SimpleCallsTest() |
331 void SimpleCallsTest() |
308 { |
332 { |
309 RSqlDatabase db, db2; |
333 RSqlDatabase db, db2; |
310 TInt err = db.Create(KTestDatabase, &KDatabasePageSizeConfig); |
334 TInt err = db.Create(TheTestDatabase, &KDatabasePageSizeConfig); |
311 TEST2(err, KErrNone); |
335 TEST2(err, KErrNone); |
312 |
336 |
313 err = db2.Open(KTestDatabase); |
337 err = db2.Open(TheTestDatabase); |
314 TEST2(err, KErrNone); |
338 TEST2(err, KErrNone); |
315 |
339 |
316 //An attempt to get an access to the reserved space (which is not reserved yet). |
340 //An attempt to get an access to the reserved space (which is not reserved yet). |
317 err = db.GetReserveAccess(); |
341 err = db.GetReserveAccess(); |
318 TEST2(err, KErrNotFound); |
342 TEST2(err, KErrNotFound); |
376 REQ5793 |
400 REQ5793 |
377 */ |
401 */ |
378 void DeleteTransactionTest() |
402 void DeleteTransactionTest() |
379 { |
403 { |
380 TVolumeIOParamInfo volIoPrm; |
404 TVolumeIOParamInfo volIoPrm; |
381 TInt err = TheFs.VolumeIOParam(KTestDrive, volIoPrm); |
405 TInt err = TheFs.VolumeIOParam(TheTestDrive, volIoPrm); |
382 TEST2(err, KErrNone); |
406 TEST2(err, KErrNone); |
383 RDebug::Print(_L("--Drive %d. BlockSize=%d, ClusterSize=%d, RecReadBufSize=%d, RecWriteBufSize=%d\r\n"), KTestDrive, volIoPrm.iBlockSize, volIoPrm.iClusterSize, volIoPrm.iRecReadBufSize, volIoPrm.iRecWriteBufSize); |
407 TheTest.Printf(_L("--Drive %d. BlockSize=%d, ClusterSize=%d, RecReadBufSize=%d, RecWriteBufSize=%d\r\n"), TheTestDrive, volIoPrm.iBlockSize, volIoPrm.iClusterSize, volIoPrm.iRecReadBufSize, volIoPrm.iRecWriteBufSize); |
384 ///////////////////////////////////////////////////////// |
408 ///////////////////////////////////////////////////////// |
385 RDebug::Print(_L("--Create and fill database \"%S\".\r\n"), &KTestDatabase); |
409 TheTest.Printf(_L("--Create and fill database \"%S\".\r\n"), &TheTestDatabase); |
386 RSqlDatabase db; |
410 RSqlDatabase db; |
387 CreateAndFillTestDatabase(db); |
411 CreateAndFillTestDatabase(db); |
388 db.Close();//When the database gets closed, the persisted journal file will be deleted. |
412 db.Close();//When the database gets closed, the persisted journal file will be deleted. |
389 RDebug::Print(_L("--Close and reopen database \"%S\" (in order to get the persisted journal file deleted).\r\n"), &KTestDatabase); |
413 TheTest.Printf(_L("--Close and reopen database \"%S\" (in order to get the persisted journal file deleted).\r\n"), &TheTestDatabase); |
390 err = db.Open(KTestDatabase); |
414 err = db.Open(TheTestDatabase); |
391 TEST2(err, KErrNone); |
415 TEST2(err, KErrNone); |
392 RDebug::Print(_L("--Reserve disk space for database \"%S\".\r\n"), &KTestDatabase); |
416 TheTest.Printf(_L("--Reserve disk space for database \"%S\".\r\n"), &TheTestDatabase); |
393 err = db.ReserveDriveSpace(0); |
417 err = db.ReserveDriveSpace(0); |
394 TEST2(err, KErrNone); |
418 TEST2(err, KErrNone); |
395 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")); |
419 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")); |
396 CreateLargeFile(); |
420 CreateLargeFile(); |
397 RDebug::Print(_L("--Attempt to delete test data records. The transaction must fail, because of \"out of disk space\".\r\n")); |
421 TheTest.Printf(_L("--Attempt to delete test data records. The transaction must fail, because of \"out of disk space\".\r\n")); |
398 err = DeleteTestRecords(db); |
422 err = DeleteTestRecords(db); |
399 TEST2(err, KErrDiskFull); |
423 TEST2(err, KErrDiskFull); |
400 RDebug::Print(_L("--Get an access to the reserved disk space.\r\n")); |
424 TheTest.Printf(_L("--Get an access to the reserved disk space.\r\n")); |
401 err = db.GetReserveAccess(); |
425 err = db.GetReserveAccess(); |
402 TEST2(err, KErrNone); |
426 TEST2(err, KErrNone); |
403 TInt64 diskSpace = ::FreeDiskSpace(); |
427 TInt64 diskSpace = ::FreeDiskSpace(); |
404 RDebug::Print(_L("After GetReserveAccess(), free disk space = %ld. Try again \"Delete records\" transaction. The transaction must not fail.\r\n"), diskSpace); |
428 TheTest.Printf(_L("After GetReserveAccess(), free disk space = %ld. Try again \"Delete records\" transaction. The transaction must not fail.\r\n"), diskSpace); |
405 err = DeleteTestRecords(db); |
429 err = DeleteTestRecords(db); |
406 RDebug::Print(_L("--DeleteTestRecords() returned %d error.\r\n"), err); |
430 TheTest.Printf(_L("--DeleteTestRecords() returned %d error.\r\n"), err); |
407 TEST(err >= 0); |
431 TEST(err >= 0); |
408 //Releases the access to the reserved disk space |
432 //Releases the access to the reserved disk space |
409 db.ReleaseReserveAccess(); |
433 db.ReleaseReserveAccess(); |
410 //Frees the reserved disk space |
434 //Frees the reserved disk space |
411 db.FreeReservedSpace(); |
435 db.FreeReservedSpace(); |
453 db1.FreeReservedSpace(); |
477 db1.FreeReservedSpace(); |
454 err = db1.ReserveDriveSpace(0); |
478 err = db1.ReserveDriveSpace(0); |
455 TEST2(err, KErrNone); |
479 TEST2(err, KErrNone); |
456 |
480 |
457 RSqlDatabase db4; |
481 RSqlDatabase db4; |
458 err = db4.Open(KTestDatabase); |
482 err = db4.Open(TheTestDatabase); |
459 TEST2(err, KErrNone); |
483 TEST2(err, KErrNone); |
460 |
484 |
461 //Try to reserve space for db4. |
485 //Try to reserve space for db4. |
462 err = db4.ReserveDriveSpace(0); |
486 err = db4.ReserveDriveSpace(0); |
463 TEST2(err, KErrNone); |
487 TEST2(err, KErrNone); |
464 |
488 |
465 RSqlDatabase db3; |
489 RSqlDatabase db3; |
466 err = db3.Open(KTestDatabase); |
490 err = db3.Open(TheTestDatabase); |
467 TEST2(err, KErrNone); |
491 TEST2(err, KErrNone); |
468 |
492 |
469 //Try to reserve space for session db3. |
493 //Try to reserve space for session db3. |
470 err = db3.ReserveDriveSpace(0); |
494 err = db3.ReserveDriveSpace(0); |
471 TEST2(err, KErrNone); |
495 TEST2(err, KErrNone); |