|
1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include "testutils.h" |
|
17 #include <bookmarkdatabase.h> |
|
18 |
|
19 _LIT(KFilename, "tsecuritytests.cpp"); |
|
20 _LIT(KTitle, "Bookmark Security Unit Tests"); |
|
21 |
|
22 _LIT(KTxtFolder1, "securityTEST Folder 1"); |
|
23 |
|
24 _LIT ( KMyFolder, "MyFolder" ); |
|
25 _LIT ( KMyNewFolder, "MyNewFolder" ); |
|
26 _LIT ( KMyFolderDesc, "Testing last modified time in bookmark." ); |
|
27 _LIT ( KMyFolderNewDesc, "1: Testing last modified time in bookmark." ); |
|
28 |
|
29 const TInt KGeneralDelay = 2*1000*1000; |
|
30 |
|
31 LOCAL_D RTest gTest(KTitle()); |
|
32 |
|
33 LOCAL_D CTrapCleanup* gTheTrapCleanup; |
|
34 LOCAL_D CTestWrapper* gTestWrapper; |
|
35 |
|
36 const TInt KTestCleanupStack=0x500; |
|
37 _LIT_SECURE_ID(KAppId,0x00001234); |
|
38 |
|
39 // Old bookmark database files path. These files will be copied into the |
|
40 // c drive bookmarks private folder. This files will be used for testing |
|
41 // missing last-modified time. |
|
42 _LIT ( KSourcePath1, "z:\\bookmarks\\testdata\\10205af8.cre" ); |
|
43 _LIT ( KDestinationPath1, "c:\\private\\10202BE9\\persists\\10205af8.cre" ); |
|
44 _LIT ( KSourcePath2, "z:\\bookmarks\\testdata\\10205af9.cre" ); |
|
45 _LIT ( KDestinationPath2, "c:\\private\\10202BE9\\persists\\10205af9.cre" ); |
|
46 _LIT ( KSourcePath3, "z:\\bookmarks\\testdata\\10205afa.cre" ); |
|
47 _LIT ( KDestinationPath3, "c:\\private\\10202BE9\\persists\\10205afa.cre" ); |
|
48 _LIT ( KSourcePath4, "z:\\bookmarks\\testdata\\10205afb.cre" ); |
|
49 _LIT ( KDestinationPath4, "c:\\private\\10202BE9\\persists\\10205afb.cre" ); |
|
50 _LIT ( KUninstallDbFiles, "c:\\private\\10202BE9\\persists\\*.cre" ); |
|
51 |
|
52 |
|
53 LOCAL_C void DoOldDbCopyL () |
|
54 { |
|
55 gTestWrapper->SetFile(KFilename); |
|
56 gTestWrapper->Next(_L("*** Copying old database files ***")); |
|
57 RFs fs; |
|
58 User::LeaveIfError ( fs.Connect () ); |
|
59 CFileMan* fileMan = CFileMan::NewL ( fs ); |
|
60 CleanupStack::PushL ( fileMan ); |
|
61 fs.MkDirAll ( KDestinationPath1 ); |
|
62 |
|
63 User::LeaveIfError ( fileMan->Copy ( KSourcePath1, KDestinationPath1 ) ); |
|
64 User::LeaveIfError ( fileMan->Copy ( KSourcePath2, KDestinationPath2 ) ); |
|
65 User::LeaveIfError ( fileMan->Copy ( KSourcePath3, KDestinationPath3 ) ); |
|
66 User::LeaveIfError ( fileMan->Copy ( KSourcePath4, KDestinationPath4 ) ); |
|
67 |
|
68 CleanupStack::PopAndDestroy ( fileMan ); |
|
69 fs.Close (); |
|
70 } |
|
71 |
|
72 |
|
73 LOCAL_C void DoOldDbRemoveL () |
|
74 { |
|
75 gTestWrapper->Next(_L("*** Removing old database files ***")); |
|
76 RFs fs; |
|
77 User::LeaveIfError ( fs.Connect () ); |
|
78 |
|
79 CFileMan* fileMan = CFileMan::NewL ( fs ); |
|
80 CleanupStack::PushL ( fileMan ); |
|
81 |
|
82 // Ensure all files are deletable. |
|
83 fileMan->Attribs ( KUninstallDbFiles, KEntryAttArchive, KEntryAttReadOnly, TTime(0), CFileMan::ERecurse ); |
|
84 |
|
85 // Delete the files. |
|
86 fileMan->Delete ( KUninstallDbFiles ); |
|
87 |
|
88 // Time for uninstall. |
|
89 User::After ( KGeneralDelay ); |
|
90 |
|
91 CleanupStack::PopAndDestroy ( fileMan ); |
|
92 fs.Close (); |
|
93 } |
|
94 |
|
95 LOCAL_C void DoSecurityTestL() |
|
96 { |
|
97 gTestWrapper->Next(_L("*** Security tests ***")); |
|
98 |
|
99 RBkDatabase database1; |
|
100 database1.OpenL(Bookmark::EVisibilityManager); |
|
101 CleanupClosePushL(database1); |
|
102 gTestWrapper->Next(_L("[Security tests] Check Public & Writable")); |
|
103 |
|
104 RBkFolder folder = database1.CreateFolderL(KTxtFolder1); |
|
105 CleanupClosePushL(folder); |
|
106 Bookmark::TItemId folderId = folder.Id(); |
|
107 CleanupStack::PopAndDestroy(&folder); |
|
108 database1.CommitL(); |
|
109 RBkFolder folder1 = database1.OpenFolderL(KTxtFolder1); |
|
110 CleanupClosePushL(folder1); |
|
111 folder1.SetOwnerL(0x00112233); |
|
112 RBkBookmark bookmark1 = database1.CreateBookmarkL(&folder1); |
|
113 CleanupClosePushL(bookmark1); |
|
114 Bookmark::TItemId bookmarkId = bookmark1.Id(); |
|
115 CleanupStack::PopAndDestroy(&bookmark1); |
|
116 CleanupStack::PopAndDestroy(&folder1); |
|
117 database1.CommitL(); |
|
118 CleanupStack::PopAndDestroy(&database1); |
|
119 |
|
120 RBkDatabase database2; |
|
121 database2.OpenL(Bookmark::EVisibilityManager); |
|
122 CleanupClosePushL(database2); |
|
123 RBkFolder folder2 = database2.OpenFolderL(KTxtFolder1); |
|
124 gTestWrapper->TEST(!folder2.IsPublic()); |
|
125 CleanupClosePushL(folder2); |
|
126 RBkBookmark bookmark2 = database2.OpenBookmarkL(bookmarkId); |
|
127 CleanupClosePushL(bookmark2); |
|
128 gTestWrapper->TEST(bookmark2.IsPublic()); |
|
129 gTestWrapper->TEST(bookmark2.OwnerL() == Bookmark::KNoOwnerId); |
|
130 bookmark2.SetOwnerL(0x00112233); |
|
131 gTestWrapper->TEST(!bookmark2.IsPublic()); |
|
132 bookmark2.SetWritableL(EFalse); |
|
133 CleanupStack::PopAndDestroy(&bookmark2); |
|
134 CleanupStack::PopAndDestroy(&folder2); |
|
135 database2.CommitL(); |
|
136 CleanupStack::PopAndDestroy(&database2); |
|
137 |
|
138 RBkDatabase database3; |
|
139 database3.OpenL(Bookmark::EVisibilityManager); |
|
140 CleanupClosePushL(database3); |
|
141 RBkBookmark bookmark3 = database3.OpenBookmarkL(bookmarkId); |
|
142 CleanupClosePushL(bookmark3); |
|
143 gTestWrapper->TEST(!bookmark3.IsPublic()); |
|
144 RThread thread; |
|
145 TSecurityInfo secInfo(thread); |
|
146 gTestWrapper->TEST(bookmark3.OwnerL() == 0x00112233); |
|
147 gTestWrapper->TEST(!bookmark3.IsWritable()); |
|
148 CleanupStack::PopAndDestroy(&bookmark3); |
|
149 database3.CommitL(); |
|
150 CleanupStack::PopAndDestroy(&database3); |
|
151 |
|
152 RBkDatabase database4; |
|
153 database4.OpenL(Bookmark::EVisibilityManager); |
|
154 CleanupClosePushL(database4); |
|
155 RBkBookmark bookmark4 = database4.OpenBookmarkL(bookmarkId); |
|
156 CleanupClosePushL(bookmark4); |
|
157 gTestWrapper->TEST(!bookmark4.IsPublic()); |
|
158 bookmark4.SetWritableL(ETrue); |
|
159 bookmark4.SetPublicL(ETrue); |
|
160 gTestWrapper->TEST(bookmark4.IsPublic()); |
|
161 CleanupStack::PopAndDestroy(&bookmark4); |
|
162 database4.DeleteItemL(folderId, ETrue); |
|
163 database4.CommitL(); |
|
164 CleanupStack::PopAndDestroy(&database4); |
|
165 } |
|
166 |
|
167 LOCAL_C void DoFolderTitleTestL() |
|
168 { |
|
169 gTestWrapper->Next(_L("[Security tests] Folder title test")); |
|
170 RBkDatabase database; |
|
171 database.OpenL(Bookmark::EVisibilityManager); |
|
172 CleanupClosePushL(database); |
|
173 RBkFolder folder = database.CreateFolderL(KTxtFolder1); |
|
174 CleanupClosePushL(folder); |
|
175 Bookmark::TItemId folderId = folder.Id(); |
|
176 CleanupStack::PopAndDestroy(&folder); |
|
177 database.CommitL(); |
|
178 folder = database.OpenFolderL(KTxtFolder1); |
|
179 CleanupClosePushL(folder); |
|
180 folder.SetOwnerL(KAppId); |
|
181 CleanupStack::PopAndDestroy(&folder); |
|
182 database.CommitL(); |
|
183 CleanupStack::PopAndDestroy(&database); |
|
184 |
|
185 database.OpenL(Bookmark::EVisibilityPrivate); |
|
186 CleanupClosePushL(database); |
|
187 RBkFolder root = database.OpenRootL(); |
|
188 CleanupClosePushL(root); |
|
189 gTestWrapper->TEST(root.Count() == 0); |
|
190 CleanupStack::PopAndDestroy(&root); |
|
191 TRAPD(err, folder = database.CreateFolderL(KTxtFolder1)); |
|
192 gTestWrapper->TESTE(err == Bookmark::KErrTitleAlreadyUsed, err); |
|
193 CleanupStack::PopAndDestroy(&database); |
|
194 |
|
195 database.OpenL(Bookmark::EVisibilityManager); |
|
196 CleanupClosePushL(database); |
|
197 database.DeleteItemL(folderId, ETrue); |
|
198 database.CommitL(); |
|
199 CleanupStack::PopAndDestroy(&database); |
|
200 } |
|
201 |
|
202 LOCAL_C void DoTestSecLastModifiedTimeL () |
|
203 { |
|
204 gTestWrapper->Next(_L("[Security tests] Test last modified time")); |
|
205 TTime currentTime; |
|
206 RBkDatabase db; |
|
207 db.OpenL (Bookmark::EVisibilityManager); |
|
208 CleanupClosePushL ( db ); |
|
209 |
|
210 // Create a new folder. |
|
211 RBkFolder folder = db.CreateFolderL ( KMyNewFolder ); |
|
212 CleanupClosePushL ( folder ); |
|
213 folder.SetDescriptionL ( KMyFolderDesc ); |
|
214 currentTime.HomeTime (); |
|
215 folder.SetLastModifiedL ( currentTime ); |
|
216 db.CommitL (); |
|
217 gTestWrapper->TEST( folder.LastModifiedL() == currentTime ); // Creation time. |
|
218 CleanupStack::PopAndDestroy ( &folder ); |
|
219 |
|
220 // Open the above created folder. |
|
221 folder = db.OpenFolderL ( KMyNewFolder ); |
|
222 CleanupClosePushL ( folder ); |
|
223 folder.SetDescriptionL ( KMyFolderNewDesc ); |
|
224 currentTime.HomeTime (); |
|
225 folder.SetLastModifiedL ( currentTime ); |
|
226 db.CommitL (); |
|
227 gTestWrapper->TEST( folder.LastModifiedL() == currentTime ); // Creation time. |
|
228 Bookmark::TItemId id = folder.Id(); |
|
229 db.DeleteItemL ( id ); // mark for deleting |
|
230 db.CommitL (); |
|
231 |
|
232 CleanupStack::PopAndDestroy ( &folder ); |
|
233 CleanupStack::PopAndDestroy ( &db ); |
|
234 } |
|
235 |
|
236 LOCAL_C void DoTestSecLastModifiedTime1L () |
|
237 { |
|
238 gTestWrapper->Next(_L("[Security tests] Test last modified time1")); |
|
239 TTime currentTime; |
|
240 |
|
241 RBkDatabase db; |
|
242 db.OpenL (Bookmark::EVisibilityManager); |
|
243 CleanupClosePushL ( db ); |
|
244 |
|
245 // Create a new folder. |
|
246 RBkFolder folder = db.CreateFolderL ( KMyNewFolder ); |
|
247 CleanupClosePushL ( folder ); |
|
248 folder.SetDescriptionL ( KMyFolderDesc ); |
|
249 currentTime.HomeTime (); |
|
250 folder.SetLastModifiedL ( currentTime ); |
|
251 db.CommitL (); |
|
252 |
|
253 CleanupStack::PopAndDestroy ( &folder ); |
|
254 CleanupStack::PopAndDestroy ( &db ); |
|
255 |
|
256 db.OpenL (Bookmark::EVisibilityManager); |
|
257 CleanupClosePushL ( db ); |
|
258 folder = db.OpenFolderL ( KMyNewFolder ); |
|
259 CleanupClosePushL ( folder ); |
|
260 gTestWrapper->TEST ( currentTime == folder.LastModifiedL() ); |
|
261 |
|
262 Bookmark::TItemId id = folder.Id(); |
|
263 db.DeleteItemL ( id ); // mark for deleting |
|
264 db.CommitL (); |
|
265 |
|
266 CleanupStack::PopAndDestroy ( &folder ); |
|
267 CleanupStack::PopAndDestroy ( &db ); |
|
268 } |
|
269 |
|
270 LOCAL_D void DoTestOldDB () |
|
271 { |
|
272 gTestWrapper->Next(_L("*** Testing old database ***")); |
|
273 RBkDatabase db; |
|
274 db.OpenL (Bookmark::EVisibilityManager); |
|
275 CleanupClosePushL ( db ); |
|
276 |
|
277 // Check for older database data. |
|
278 RBkFolder folder = db.OpenFolderL ( KMyFolder ); |
|
279 CleanupClosePushL ( folder ); |
|
280 Bookmark::TItemId id = folder.Id (); |
|
281 TDateTime dt ( 1970, EJanuary, 1, 0, 0, 0, 0 ); |
|
282 TTime currentTime ( dt ); |
|
283 |
|
284 gTestWrapper->TEST( folder.LastModifiedL() == currentTime ); |
|
285 |
|
286 CleanupStack::PopAndDestroy ( &folder ); |
|
287 |
|
288 CleanupStack::PopAndDestroy ( &db ); |
|
289 } |
|
290 |
|
291 LOCAL_C void DoTestsL() |
|
292 { |
|
293 DoOldDbCopyL (); |
|
294 DoTestOldDB (); |
|
295 DoOldDbRemoveL (); |
|
296 DoSecurityTestL(); |
|
297 DoFolderTitleTestL(); |
|
298 DoTestSecLastModifiedTimeL (); |
|
299 DoTestSecLastModifiedTime1L (); |
|
300 DoOldDbRemoveL (); |
|
301 } |
|
302 |
|
303 LOCAL_C void TestL() |
|
304 { |
|
305 gTestWrapper = CTestWrapper::NewLC(gTest); |
|
306 gTestWrapper->Start(_L("@SYMTestCaseID IWS-APPPROTOCOLS-BOOKMARKS-TSECURITYTESTS-0001 test")); |
|
307 |
|
308 TRAPD(ret,DoTestsL()); |
|
309 gTestWrapper->TESTE(ret==KErrNone, ret); |
|
310 |
|
311 gTestWrapper->End(); |
|
312 CleanupStack::PopAndDestroy(gTestWrapper); |
|
313 } |
|
314 |
|
315 LOCAL_C void setupCleanup() |
|
316 // |
|
317 // Initialise the cleanup stack. |
|
318 // |
|
319 { |
|
320 gTheTrapCleanup=CTrapCleanup::New(); |
|
321 gTest(gTheTrapCleanup!=NULL); |
|
322 TRAPD(r,\ |
|
323 {\ |
|
324 for (TInt i=KTestCleanupStack;i>0;i--)\ |
|
325 CleanupStack::PushL((TAny*)0);\ |
|
326 CleanupStack::Pop(KTestCleanupStack);\ |
|
327 }); |
|
328 gTest(r==KErrNone); |
|
329 } |
|
330 |
|
331 |
|
332 GLDEF_C TInt E32Main() |
|
333 { |
|
334 setupCleanup(); |
|
335 __UHEAP_MARK; |
|
336 // |
|
337 |
|
338 TRAPD(ret,TestL()); |
|
339 gTest(ret==KErrNone); |
|
340 // |
|
341 |
|
342 __UHEAP_MARKEND; |
|
343 delete gTheTrapCleanup; |
|
344 return KErrNone; |
|
345 } |
|
346 |