|
1 // Copyright (c) 2002-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 the License "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 <e32kpan.h> |
|
17 #include "t_property.h" |
|
18 |
|
19 _LIT(KDefineName, "RProperty::Define() Basics"); |
|
20 |
|
21 CPropDefine::CPropDefine(TUid aCategory, TUint aKey, RProperty::TType aType) : |
|
22 CTestProgram(KDefineName), iCategory(aCategory), iKey(aKey), iType(aType) |
|
23 { |
|
24 } |
|
25 |
|
26 void CPropDefine::Run(TUint aCount) |
|
27 { |
|
28 TUid mySid; |
|
29 mySid.iUid = RProcess().SecureId(); |
|
30 |
|
31 for(TUint i = 0; i < aCount; ++i) |
|
32 { |
|
33 RProperty prop; |
|
34 |
|
35 // Defines the attributes and access control for a property. This can only be done |
|
36 // once for each property. Subsequent attempts to define the same property will return |
|
37 // KErrAlreadyExists. |
|
38 TInt r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
39 TF_ERROR(r, r == KErrNone); |
|
40 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
41 TF_ERROR(r, r == KErrAlreadyExists); |
|
42 r = prop.Delete(iCategory, iKey); |
|
43 TF_ERROR(r, r == KErrNone); |
|
44 |
|
45 // Test defining properties in the default category (==our SID) |
|
46 r = prop.Define(iKey, iType, KFailPolicy, KFailPolicy); |
|
47 TF_ERROR(r, r == KErrNone); |
|
48 r = prop.Define(iKey, iType, KFailPolicy, KFailPolicy); |
|
49 TF_ERROR(r, r == KErrAlreadyExists); |
|
50 r = prop.Define(mySid, iKey, iType, KFailPolicy, KFailPolicy); |
|
51 TF_ERROR(r, r == KErrAlreadyExists); |
|
52 r = prop.Delete(mySid, iKey); |
|
53 TF_ERROR(r, r == KErrNone); |
|
54 |
|
55 // Test re-definition doesn't change security settings |
|
56 // Defect DEF050961 - Re-defining an RProperty causes the security policy to be overwritten |
|
57 { |
|
58 TInt expectedResult = PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement)?KErrPermissionDenied:KErrNone; |
|
59 _LIT(KTestBytes,"abcd"); |
|
60 r = prop.Define(iCategory, iKey, iType, KFailPolicy, KFailPolicy); |
|
61 TF_ERROR(r, r == KErrNone); |
|
62 r = prop.Attach(iCategory, iKey); |
|
63 TF_ERROR(r, r == KErrNone); |
|
64 if (iType == RProperty::EInt) |
|
65 r = prop.Set(1); |
|
66 else |
|
67 r = prop.Set(KTestBytes); |
|
68 TF_ERROR(r, r == expectedResult); |
|
69 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
70 TF_ERROR(r, r == KErrAlreadyExists); |
|
71 if (iType == RProperty::EInt) |
|
72 r = prop.Set(1); |
|
73 else |
|
74 r = prop.Set(KTestBytes); |
|
75 TF_ERROR(r, r == expectedResult); |
|
76 r = prop.Delete(iCategory, iKey); |
|
77 TF_ERROR(r, r == KErrNone); |
|
78 prop.Close(); |
|
79 } |
|
80 |
|
81 // Define fails with KErrArgument if wrong type or attribute was specified. |
|
82 r = prop.Define(iCategory, iKey, RProperty::ETypeLimit, KPassPolicy, KPassPolicy); |
|
83 TF_ERROR(r, r == KErrArgument); |
|
84 const TInt removed_KPersistent_attribute = 0x100; |
|
85 r = prop.Define(iCategory, iKey, iType | removed_KPersistent_attribute, KPassPolicy, KPassPolicy); |
|
86 TF_ERROR(r, r == KErrArgument); |
|
87 |
|
88 TSecurityPolicy badPolicy; |
|
89 *(TInt*)&badPolicy = -1; |
|
90 r = prop.Define(iCategory, iKey, iType, badPolicy, KPassPolicy); |
|
91 TF_ERROR(r, r == KErrArgument); |
|
92 r = prop.Define(iCategory, iKey, iType, KPassPolicy, badPolicy); |
|
93 TF_ERROR(r, r == KErrArgument); |
|
94 |
|
95 if (iType == RProperty::EInt) |
|
96 { |
|
97 // Define fails with KErrArgument if aType is TInt and aPreallocate is not 0 |
|
98 r = prop.Define(iCategory, iKey, RProperty::EInt, KPassPolicy, KPassPolicy, 16); |
|
99 TF_ERROR(r, r == KErrArgument); |
|
100 |
|
101 // Following defintion the property has a default value, 0 for integer properties |
|
102 r = prop.Define(iCategory, iKey, RProperty::EInt, KPassPolicy, KPassPolicy); |
|
103 TF_ERROR(r, r == KErrNone); |
|
104 TInt value; |
|
105 r = prop.Get(iCategory, iKey, value); |
|
106 TF_ERROR(r, r == KErrNone); |
|
107 TF_ERROR(value, value == 0); |
|
108 r = prop.Delete(iCategory, iKey); |
|
109 TF_ERROR(r, r == KErrNone); |
|
110 } |
|
111 else |
|
112 { |
|
113 // Defne fails with KErrTooBig if aPeallocate is grater than KMaxPropertySize. |
|
114 r = prop.Define(iCategory, iKey, RProperty::EByteArray, KPassPolicy, KPassPolicy, RProperty::KMaxPropertySize); |
|
115 TF_ERROR(r, r == KErrNone); |
|
116 r = prop.Delete(iCategory, iKey); |
|
117 TF_ERROR(r, r == KErrNone); |
|
118 r = prop.Define(iCategory, iKey, RProperty::EByteArray, KPassPolicy, KPassPolicy, RProperty::KMaxPropertySize + 1); |
|
119 TF_ERROR(r, r == KErrTooBig); |
|
120 |
|
121 // Following defintion the property has a default value, zero-length data for byte-array and text |
|
122 // properties. |
|
123 r = prop.Define(iCategory, iKey, RProperty::EByteArray, KPassPolicy, KPassPolicy); |
|
124 TF_ERROR(r, r == KErrNone); |
|
125 TBuf<16> buf; |
|
126 r = prop.Get(iCategory, iKey, buf); |
|
127 TF_ERROR(r, r == KErrNone); |
|
128 TF_ERROR(buf.Size(), buf.Size() == 0); |
|
129 |
|
130 TBuf8<16> buf8; |
|
131 r = prop.Get(iCategory, iKey, buf8); |
|
132 TF_ERROR(r, r == KErrNone); |
|
133 TF_ERROR(buf8.Size(), buf8.Size() == 0); |
|
134 r = prop.Delete(iCategory, iKey); |
|
135 TF_ERROR(r, r == KErrNone); |
|
136 } |
|
137 |
|
138 // Pending subscriptions for this property will not be completed until a new value is published. |
|
139 r = prop.Attach(iCategory, iKey); |
|
140 TF_ERROR(r, r == KErrNone); |
|
141 TRequestStatus status; |
|
142 prop.Subscribe(status); |
|
143 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
144 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
145 TF_ERROR(r, r == KErrNone); |
|
146 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
147 r = prop.Delete(iCategory, iKey); |
|
148 TF_ERROR(r, r == KErrNone); |
|
149 User::WaitForRequest(status); |
|
150 TF_ERROR(status.Int(), status.Int() == KErrNotFound); |
|
151 prop.Close(); |
|
152 } |
|
153 } |
|
154 |
|
155 _LIT(KDeleteName, "RProperty::Delete() Basics"); |
|
156 |
|
157 CPropDelete::CPropDelete(TUid aCategory, TUint aKey, RProperty::TType aType) : |
|
158 CTestProgram(KDeleteName), iCategory(aCategory), iKey(aKey), iType(aType) |
|
159 { |
|
160 } |
|
161 |
|
162 void CPropDelete::Run(TUint aCount) |
|
163 { |
|
164 TUid mySid; |
|
165 mySid.iUid = RProcess().SecureId(); |
|
166 for(TUint i = 0; i < aCount; ++i) |
|
167 { |
|
168 RProperty prop; |
|
169 |
|
170 // If the property has not been defined Delete fails with KErrNotFound. |
|
171 TInt r = prop.Delete(iCategory, iKey); |
|
172 TF_ERROR(r, r == KErrNotFound); |
|
173 |
|
174 // Test deleting properties in the default category (==our SID) |
|
175 //deleting of property in the default category (==our SID) should fail until the property is defined |
|
176 r = prop.Delete(iKey); |
|
177 TF_ERROR(r, r == KErrNotFound); |
|
178 |
|
179 r = prop.Define(iKey, iType, KFailPolicy, KFailPolicy); |
|
180 TF_ERROR(r, r == KErrNone); |
|
181 r = prop.Delete(iKey); |
|
182 TF_ERROR(r, r == KErrNone); |
|
183 |
|
184 r = prop.Define(mySid, iKey, iType, KFailPolicy, KFailPolicy); |
|
185 TF_ERROR(r, r == KErrNone); |
|
186 r = prop.Delete(mySid, iKey); |
|
187 TF_ERROR(r, r == KErrNone); |
|
188 r = prop.Delete( iKey); |
|
189 TF_ERROR(r, r == KErrNotFound); |
|
190 |
|
191 r = prop.Define(mySid, iKey, iType, KFailPolicy, KFailPolicy); |
|
192 TF_ERROR(r, r == KErrNone); |
|
193 r = prop.Delete( iKey); |
|
194 TF_ERROR(r, r == KErrNone); |
|
195 r = prop.Delete(mySid, iKey); |
|
196 TF_ERROR(r, r == KErrNotFound); |
|
197 |
|
198 // Any pending subscriptions for this property will be completed with KErrNotFound. |
|
199 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
200 TF_ERROR(r, r == KErrNone); |
|
201 r = prop.Attach(iCategory, iKey); |
|
202 TF_ERROR(r, r == KErrNone); |
|
203 TRequestStatus status; |
|
204 prop.Subscribe(status); |
|
205 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
206 r = prop.Delete(iCategory, iKey); |
|
207 TF_ERROR(r, r == KErrNone); |
|
208 User::WaitForRequest(status); |
|
209 TF_ERROR(status.Int(), status.Int() == KErrNotFound); |
|
210 |
|
211 // Any new request will not complete until the property is defined and published again. |
|
212 prop.Subscribe(status); |
|
213 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
214 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
215 TF_ERROR(r, r == KErrNone); |
|
216 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
217 if (iType == RProperty::EInt) |
|
218 { |
|
219 r = prop.Set(1); |
|
220 TF_ERROR(r, r == KErrNone); |
|
221 } |
|
222 else |
|
223 { |
|
224 r = prop.Set(_L("Foo")); |
|
225 TF_ERROR(r, r == KErrNone); |
|
226 } |
|
227 User::WaitForRequest(status); |
|
228 TF_ERROR(status.Int(), status.Int() == KErrNone); |
|
229 r = prop.Delete(iCategory, iKey); |
|
230 TF_ERROR(r, r == KErrNone); |
|
231 prop.Close(); |
|
232 } |
|
233 } |
|
234 |
|
235 _LIT(KPanicName, "RProperty Panics"); |
|
236 |
|
237 CPropPanic::CPropPanic(TUid aCategory, TUint aKey) : |
|
238 CTestProgram(KPanicName), iCategory(aCategory), iKey(aKey) |
|
239 { |
|
240 } |
|
241 |
|
242 TInt CPropPanic::DoubleSubscribeThreadEntry(TAny* ptr) |
|
243 { |
|
244 CPropPanic* prog = (CPropPanic*) ptr; |
|
245 RProperty prop; |
|
246 TInt r = prop.Attach(prog->iCategory, prog->iKey, EOwnerThread); |
|
247 TF_ERROR_PROG(prog, r, r == KErrNone); |
|
248 TRequestStatus status; |
|
249 prop.Subscribe(status); |
|
250 // Next statement shall Panic. |
|
251 prop.Subscribe(status); |
|
252 // Never get here |
|
253 return KErrNone; |
|
254 } |
|
255 |
|
256 TInt CPropPanic::BadHandleSubscribeThreadEntry(TAny* /*ptr*/) |
|
257 { |
|
258 RProperty prop; |
|
259 TRequestStatus status; |
|
260 prop.Subscribe(status); |
|
261 return KErrNone; |
|
262 } |
|
263 |
|
264 TInt CPropPanic::BadHandleCancelThreadEntry(TAny* /*ptr*/) |
|
265 { |
|
266 RProperty prop; |
|
267 prop.Cancel(); |
|
268 return KErrNone; |
|
269 } |
|
270 |
|
271 TInt CPropPanic::BadHandleGetIThreadEntry(TAny* /*ptr*/) |
|
272 { |
|
273 RProperty prop; |
|
274 TInt i; |
|
275 prop.Get(i); |
|
276 return KErrNone; |
|
277 } |
|
278 |
|
279 TInt CPropPanic::BadHandleGetBThreadEntry(TAny* /*ptr*/) |
|
280 { |
|
281 RProperty prop; |
|
282 TBuf<64> buf; |
|
283 prop.Get(buf); |
|
284 return KErrNone; |
|
285 } |
|
286 |
|
287 TInt CPropPanic::BadHandleSetIThreadEntry(TAny* /*ptr*/) |
|
288 { |
|
289 RProperty prop; |
|
290 TInt i = 1; |
|
291 prop.Set(i); |
|
292 return KErrNone; |
|
293 } |
|
294 |
|
295 TInt CPropPanic::BadHandleSetBThreadEntry(TAny* /*ptr*/) |
|
296 { |
|
297 RProperty prop; |
|
298 TBuf<64> buf; |
|
299 prop.Set(buf); |
|
300 return KErrNone; |
|
301 } |
|
302 |
|
303 TThreadFunction CPropPanic::BadHandles[] = { |
|
304 CPropPanic::BadHandleSubscribeThreadEntry, |
|
305 CPropPanic::BadHandleCancelThreadEntry, |
|
306 CPropPanic::BadHandleGetIThreadEntry, |
|
307 CPropPanic::BadHandleGetBThreadEntry, |
|
308 CPropPanic::BadHandleSetIThreadEntry, |
|
309 CPropPanic::BadHandleSetBThreadEntry, |
|
310 NULL |
|
311 }; |
|
312 |
|
313 void CPropPanic::Run(TUint /* aCount */) |
|
314 { |
|
315 // Only one subscriptoin per RProperty object is allowed, the caller will be paniced if |
|
316 // there is already a subscription on this object. |
|
317 TRequestStatus status; |
|
318 TExitType exit; |
|
319 RThread thr; |
|
320 TInt r = thr.Create(KNullDesC, DoubleSubscribeThreadEntry, 0x2000, NULL, this); |
|
321 TF_ERROR(r, r == KErrNone); |
|
322 thr.Logon(status); |
|
323 |
|
324 TBool jit = User::JustInTime(); |
|
325 User::SetJustInTime(EFalse); |
|
326 |
|
327 thr.Resume(); |
|
328 User::WaitForRequest(status); |
|
329 thr.Close(); |
|
330 |
|
331 User::SetJustInTime(jit); |
|
332 |
|
333 TF_ERROR(status.Int(), status.Int() == ERequestAlreadyPending); |
|
334 |
|
335 for (TInt i = 0; BadHandles[i]; ++i) |
|
336 { |
|
337 r = thr.Create(KNullDesC, BadHandles[i], 0x2000, NULL, this); |
|
338 TF_ERROR(r, r == KErrNone); |
|
339 thr.Logon(status); |
|
340 |
|
341 jit = User::JustInTime(); |
|
342 User::SetJustInTime(EFalse); |
|
343 |
|
344 thr.Resume(); |
|
345 User::WaitForRequest(status); |
|
346 exit = thr.ExitType(); |
|
347 thr.Close(); |
|
348 |
|
349 User::SetJustInTime(jit); |
|
350 |
|
351 TF_ERROR(status.Int(), status.Int() == EBadHandle); |
|
352 TF_ERROR(exit, exit == EExitPanic); |
|
353 } |
|
354 } |
|
355 |
|
356 _LIT(KSetGetName, "RProperty::Set()/Get() Basics"); |
|
357 |
|
358 CPropSetGet::CPropSetGet(TUid aCategory, TUint aKey, RProperty::TType aType) : |
|
359 CTestProgram(KSetGetName), iCategory(aCategory), iKey(aKey), iType(aType) |
|
360 { |
|
361 } |
|
362 |
|
363 void CPropSetGet::Run(TUint aCount) |
|
364 { |
|
365 for(TUint i = 0; i < aCount; ++i) |
|
366 { |
|
367 TInt r; |
|
368 RProperty prop; |
|
369 |
|
370 r = prop.Attach(iCategory, iKey); |
|
371 TF_ERROR(r, r == KErrNone); |
|
372 |
|
373 // If the property has not been defined this fails with KErrNotFound. |
|
374 { |
|
375 TInt value; |
|
376 TBuf<16> buf; |
|
377 TBuf8<16> buf8; |
|
378 if (iType == RProperty::EInt) |
|
379 { |
|
380 r = prop.Get(iCategory, iKey, value); |
|
381 TF_ERROR(r, r == KErrNotFound); |
|
382 r = prop.Set(iCategory, iKey, value); |
|
383 TF_ERROR(r, r == KErrNotFound); |
|
384 } |
|
385 else |
|
386 { |
|
387 r = prop.Get(iCategory, iKey, buf); |
|
388 TF_ERROR(r, r == KErrNotFound); |
|
389 r = prop.Set(iCategory, iKey, buf); |
|
390 TF_ERROR(r, r == KErrNotFound); |
|
391 r = prop.Get(iCategory, iKey, buf8); |
|
392 TF_ERROR(r, r == KErrNotFound); |
|
393 r = prop.Set(iCategory, iKey, buf8); |
|
394 TF_ERROR(r, r == KErrNotFound); |
|
395 } |
|
396 |
|
397 if (iType == RProperty::EInt) |
|
398 { |
|
399 r = prop.Get(value); |
|
400 TF_ERROR(r, r == KErrNotFound); |
|
401 r = prop.Set(value); |
|
402 TF_ERROR(r, r == KErrNotFound); |
|
403 } |
|
404 else |
|
405 { |
|
406 r = prop.Get(buf); |
|
407 TF_ERROR(r, r == KErrNotFound); |
|
408 r = prop.Set(buf); |
|
409 TF_ERROR(r, r == KErrNotFound); |
|
410 r = prop.Get(buf8); |
|
411 TF_ERROR(r, r == KErrNotFound); |
|
412 r = prop.Set(buf8); |
|
413 TF_ERROR(r, r == KErrNotFound); |
|
414 } |
|
415 } |
|
416 |
|
417 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
418 TF_ERROR(r, r == KErrNone); |
|
419 |
|
420 // Can set property to zero length |
|
421 { |
|
422 if (iType == RProperty::EByteArray) |
|
423 { |
|
424 TBuf8<20> buf8(20); |
|
425 r = prop.Set(iCategory, iKey, KNullDesC8); |
|
426 TF_ERROR(r, r == KErrNone); |
|
427 r = prop.Get(iCategory, iKey, buf8); |
|
428 TF_ERROR(r, r == KErrNone); |
|
429 TF_ERROR(buf8.Length(), buf8.Length() == 0); |
|
430 } |
|
431 } |
|
432 |
|
433 // If the property is larger than KMaxPropertySize this fails with KErrTooBig |
|
434 { |
|
435 if (iType == RProperty::EByteArray) |
|
436 { |
|
437 TBuf<RProperty::KMaxPropertySize/2 + 1> buf(RProperty::KMaxPropertySize/2 + 1); |
|
438 TBuf8<RProperty::KMaxPropertySize + 1> buf8(RProperty::KMaxPropertySize + 1); |
|
439 r = prop.Set(iCategory, iKey, buf); |
|
440 TF_ERROR(r, r == KErrTooBig); |
|
441 r = prop.Set(iCategory, iKey, buf8); |
|
442 TF_ERROR(r, r == KErrTooBig); |
|
443 r = prop.Set(buf); |
|
444 TF_ERROR(r, r == KErrTooBig); |
|
445 r = prop.Set(buf8); |
|
446 TF_ERROR(r, r == KErrTooBig); |
|
447 } |
|
448 } |
|
449 |
|
450 // When type of operation mismatch with the property type this fails with KErrArgument. |
|
451 { |
|
452 TInt value; |
|
453 TBuf<16> buf; |
|
454 TBuf8<16> buf8; |
|
455 if (iType != RProperty::EInt) |
|
456 { |
|
457 r = prop.Get(iCategory, iKey, value); |
|
458 TF_ERROR(r, r == KErrArgument); |
|
459 r = prop.Set(iCategory, iKey, value); |
|
460 TF_ERROR(r, r == KErrArgument); |
|
461 r = prop.Get(value); |
|
462 TF_ERROR(r, r == KErrArgument); |
|
463 r = prop.Set(value); |
|
464 TF_ERROR(r, r == KErrArgument); |
|
465 } |
|
466 else |
|
467 { |
|
468 r = prop.Get(iCategory, iKey, buf); |
|
469 TF_ERROR(r, r == KErrArgument); |
|
470 r = prop.Set(iCategory, iKey, buf); |
|
471 TF_ERROR(r, r == KErrArgument); |
|
472 r = prop.Get(iCategory, iKey, buf8); |
|
473 TF_ERROR(r, r == KErrArgument); |
|
474 r = prop.Set(iCategory, iKey, buf8); |
|
475 TF_ERROR(r, r == KErrArgument); |
|
476 r = prop.Get(buf); |
|
477 TF_ERROR(r, r == KErrArgument); |
|
478 r = prop.Set(buf); |
|
479 TF_ERROR(r, r == KErrArgument); |
|
480 r = prop.Get(buf8); |
|
481 TF_ERROR(r, r == KErrArgument); |
|
482 r = prop.Set(buf8); |
|
483 TF_ERROR(r, r == KErrArgument); |
|
484 } |
|
485 } |
|
486 |
|
487 // Get/Set |
|
488 if (iType == RProperty::EInt) |
|
489 { |
|
490 { |
|
491 r = prop.Set(1); |
|
492 TF_ERROR(r, r == KErrNone); |
|
493 TInt value = 0; |
|
494 r = prop.Get(value); |
|
495 TF_ERROR(r, r == KErrNone); |
|
496 TF_ERROR(value, value == 1); |
|
497 } |
|
498 { |
|
499 TInt value = 0; |
|
500 r = prop.Set(iCategory, iKey, 1); |
|
501 TF_ERROR(r, r == KErrNone); |
|
502 r = prop.Get(iCategory, iKey, value); |
|
503 TF_ERROR(r, r == KErrNone); |
|
504 TF_ERROR(value, value == 1); |
|
505 } |
|
506 } |
|
507 else |
|
508 { |
|
509 { |
|
510 TBuf<16> ibuf(_L("Foo")); |
|
511 TBuf<16> obuf; |
|
512 r = prop.Set(ibuf); |
|
513 TF_ERROR(r, r == KErrNone); |
|
514 r = prop.Get(obuf); |
|
515 TF_ERROR(r, r == KErrNone); |
|
516 r = obuf.Compare(ibuf); |
|
517 TF_ERROR(r, r == 0); |
|
518 } |
|
519 { |
|
520 TBuf8<16> ibuf8((TUint8*)"Foo"); |
|
521 TBuf8<16> obuf8; |
|
522 r = prop.Set(ibuf8); |
|
523 TF_ERROR(r, r == KErrNone); |
|
524 r = prop.Get(obuf8); |
|
525 TF_ERROR(r, r == KErrNone); |
|
526 r = obuf8.Compare(ibuf8); |
|
527 TF_ERROR(r, r == 0); |
|
528 } |
|
529 { |
|
530 TBuf<16> ibuf(_L("Foo")); |
|
531 TBuf<16> obuf; |
|
532 r = prop.Set(iCategory, iKey, ibuf); |
|
533 TF_ERROR(r, r == KErrNone); |
|
534 r = prop.Get(iCategory, iKey, obuf); |
|
535 TF_ERROR(r, r == KErrNone); |
|
536 r = obuf.Compare(ibuf); |
|
537 TF_ERROR(r, r == 0); |
|
538 } |
|
539 { |
|
540 TBuf8<16> ibuf8((TUint8*)"Foo"); |
|
541 TBuf8<16> obuf8; |
|
542 r = prop.Set(iCategory, iKey, ibuf8); |
|
543 TF_ERROR(r, r == KErrNone); |
|
544 r = prop.Get(iCategory, iKey, obuf8); |
|
545 TF_ERROR(r, r == KErrNone); |
|
546 r = obuf8.Compare(ibuf8); |
|
547 TF_ERROR(r, r == 0); |
|
548 } |
|
549 } |
|
550 |
|
551 // If the supplied buffer is too small this fails with KErrOverflow and the truncated value is reported. |
|
552 if (iType == RProperty::EByteArray) |
|
553 { |
|
554 { |
|
555 TBuf<16> ibuf(_L("0123456789012345")); |
|
556 TBuf<16> obuf(_L("abcdefghigklmnop")); |
|
557 TPtr optr((TUint16*) obuf.Ptr(), 0, 15); |
|
558 r = prop.Set(iCategory, iKey, ibuf); |
|
559 TF_ERROR(r, r == KErrNone); |
|
560 r = prop.Get(iCategory, iKey, optr); |
|
561 TF_ERROR(r, r == KErrOverflow); |
|
562 TF_ERROR(optr.Length(), optr.Length() == 15); |
|
563 TF_ERROR(obuf[14], obuf[14] == TText('4')); |
|
564 TF_ERROR(obuf[15], obuf[15] == TText('p')); |
|
565 } |
|
566 { |
|
567 TBuf8<16> ibuf8((TUint8*) "0123456789012345"); |
|
568 TBuf8<16> obuf8((TUint8*) "abcdefghigklmnop"); |
|
569 TPtr8 optr8((TUint8*) obuf8.Ptr(), 0, 15); |
|
570 r = prop.Set(iCategory, iKey, ibuf8); |
|
571 TF_ERROR(r, r == KErrNone); |
|
572 r = prop.Get(iCategory, iKey, optr8); |
|
573 TF_ERROR(r, r == KErrOverflow); |
|
574 TF_ERROR(optr8.Length(), optr8.Length() == 15); |
|
575 TF_ERROR(obuf8[14], obuf8[14] == '4'); |
|
576 TF_ERROR(obuf8[15], obuf8[15] == 'p'); |
|
577 } |
|
578 { |
|
579 TBuf<16> ibuf(_L("0123456789012345")); |
|
580 TBuf<16> obuf(_L("abcdefghigklmnop")); |
|
581 TPtr optr((TUint16*) obuf.Ptr(), 0, 15); |
|
582 r = prop.Set(ibuf); |
|
583 TF_ERROR(r, r == KErrNone); |
|
584 r = prop.Get(optr); |
|
585 TF_ERROR(r, r == KErrOverflow); |
|
586 TF_ERROR(optr.Length(), optr.Length() == 15); |
|
587 TF_ERROR(obuf[14], obuf[14] == TText('4')); |
|
588 TF_ERROR(obuf[15], obuf[15] == TText('p')); |
|
589 } |
|
590 { |
|
591 TBuf8<16> ibuf8((TUint8*) "0123456789012345"); |
|
592 TBuf8<16> obuf8((TUint8*) "abcdefghigklmnop"); |
|
593 TPtr8 optr8((TUint8*) obuf8.Ptr(), 0, 15); |
|
594 r = prop.Set(ibuf8); |
|
595 TF_ERROR(r, r == KErrNone); |
|
596 r = prop.Get(optr8); |
|
597 TF_ERROR(r, r == KErrOverflow); |
|
598 TF_ERROR(optr8.Length(), optr8.Length() == 15); |
|
599 TF_ERROR(obuf8[14], obuf8[14] == '4'); |
|
600 TF_ERROR(obuf8[15], obuf8[15] == 'p'); |
|
601 } |
|
602 } |
|
603 |
|
604 // Get/Set zero-length data |
|
605 if (iType == RProperty::EByteArray) |
|
606 { |
|
607 { |
|
608 TBuf<16> ibuf(_L("Foo")); |
|
609 TBuf<16> obuf; |
|
610 TPtr nullbuf(NULL, 0); |
|
611 |
|
612 r = prop.Set(ibuf); |
|
613 TF_ERROR(r, r == KErrNone); |
|
614 r = prop.Get(nullbuf); |
|
615 TF_ERROR(r, r == KErrOverflow); |
|
616 TF_ERROR(nullbuf.Length(), (nullbuf.Length() == 0)); |
|
617 |
|
618 r = prop.Set(nullbuf); |
|
619 TF_ERROR(r, r == KErrNone); |
|
620 r = prop.Get(obuf); |
|
621 TF_ERROR(r, r == KErrNone); |
|
622 TF_ERROR(obuf.Length(), (obuf.Length() == 0)); |
|
623 } |
|
624 { |
|
625 TBuf8<16> ibuf((TUint8*) "Foo"); |
|
626 TBuf8<16> obuf; |
|
627 TPtr8 nullbuf(NULL, 0); |
|
628 |
|
629 r = prop.Set(ibuf); |
|
630 TF_ERROR(r, r == KErrNone); |
|
631 r = prop.Get(nullbuf); |
|
632 TF_ERROR(r, r == KErrOverflow); |
|
633 TF_ERROR(nullbuf.Length(), (nullbuf.Length() == 0)); |
|
634 |
|
635 r = prop.Set(nullbuf); |
|
636 TF_ERROR(r, r == KErrNone); |
|
637 r = prop.Get(obuf); |
|
638 TF_ERROR(r, r == KErrNone); |
|
639 TF_ERROR(obuf.Length(), (obuf.Length() == 0)); |
|
640 } |
|
641 } |
|
642 |
|
643 r = prop.Delete(iCategory, iKey); |
|
644 TF_ERROR(r, r == KErrNone); |
|
645 prop.Close(); |
|
646 } |
|
647 } |
|
648 |
|
649 |
|
650 _LIT(KSubsCancelName, "RProperty::Subscribe()/Cancel() Basics"); |
|
651 |
|
652 CPropSubsCancel::CPropSubsCancel(TUid aCategory, TUint aKey, RProperty::TType aType) : |
|
653 CTestProgram(KSubsCancelName), iCategory(aCategory), iKey(aKey), iType(aType) |
|
654 { |
|
655 } |
|
656 |
|
657 |
|
658 void CPropSubsCancel::Run(TUint aCount) |
|
659 { |
|
660 |
|
661 for(TUint i = 0; i < aCount; ++i) |
|
662 { |
|
663 TRequestStatus status; |
|
664 RProperty prop; |
|
665 |
|
666 TInt r = prop.Attach(iCategory, iKey); |
|
667 TF_ERROR(r, r == KErrNone); |
|
668 |
|
669 // The calling thread will have the specified request status signalled when the property is next updated. |
|
670 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
671 TF_ERROR(r, r == KErrNone); |
|
672 prop.Subscribe(status); |
|
673 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
674 if (iType == RProperty::EInt) |
|
675 { |
|
676 r = prop.Set(1); |
|
677 TF_ERROR(r, r == KErrNone); |
|
678 } |
|
679 else |
|
680 { |
|
681 r = prop.Set(_L("Foo")); |
|
682 TF_ERROR(r, r == KErrNone); |
|
683 } |
|
684 User::WaitForRequest(status); |
|
685 TF_ERROR(status.Int(), status.Int() == KErrNone); |
|
686 r = prop.Delete(iCategory, iKey); |
|
687 TF_ERROR(r, r == KErrNone); |
|
688 |
|
689 // If the property has not been defined, the request will not complete until the property |
|
690 // is defined and published. |
|
691 prop.Subscribe(status); |
|
692 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
693 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
694 TF_ERROR(r, r == KErrNone); |
|
695 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
696 if (iType == RProperty::EInt) |
|
697 { |
|
698 r = prop.Set(1); |
|
699 TF_ERROR(r, r == KErrNone); |
|
700 } |
|
701 else |
|
702 { |
|
703 r = prop.Set(_L("Foo")); |
|
704 TF_ERROR(r, r == KErrNone); |
|
705 } |
|
706 User::WaitForRequest(status); |
|
707 TF_ERROR(status.Int(), status.Int() == KErrNone); |
|
708 r = prop.Delete(iCategory, iKey); |
|
709 TF_ERROR(r, r == KErrNone); |
|
710 |
|
711 // Cancel an outstanding subscription request for this property handle. |
|
712 // If it has not already completed, the request is completed with KErrCancelled. |
|
713 prop.Subscribe(status); |
|
714 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
715 prop.Cancel(); |
|
716 User::WaitForRequest(status); |
|
717 TF_ERROR(status.Int(), status.Int() == KErrCancel); |
|
718 |
|
719 r = prop.Define(iCategory, iKey, iType, KPassPolicy, KPassPolicy); |
|
720 TF_ERROR(r, r == KErrNone); |
|
721 prop.Subscribe(status); |
|
722 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
723 if (iType == RProperty::EInt) |
|
724 { |
|
725 r = prop.Set(1); |
|
726 TF_ERROR(r, r == KErrNone); |
|
727 } |
|
728 else |
|
729 { |
|
730 r = prop.Set(_L("Foo")); |
|
731 TF_ERROR(r, r == KErrNone); |
|
732 } |
|
733 User::WaitForRequest(status); |
|
734 TF_ERROR(status.Int(), status.Int() == KErrNone); |
|
735 prop.Cancel(); |
|
736 TF_ERROR(status.Int(), status.Int() == KErrNone); |
|
737 |
|
738 prop.Subscribe(status); |
|
739 TF_ERROR(status.Int(), status.Int() == KRequestPending); |
|
740 prop.Cancel(); |
|
741 User::WaitForRequest(status); |
|
742 TF_ERROR(status.Int(), status.Int() == KErrCancel); |
|
743 |
|
744 r = prop.Delete(iCategory, iKey); |
|
745 TF_ERROR(r, r == KErrNone); |
|
746 |
|
747 prop.Close(); |
|
748 } |
|
749 } |
|
750 |
|
751 _LIT(KSecurityName, "RProperty Security Basics (Master)"); |
|
752 |
|
753 CPropSecurity::CPropSecurity(TUid aCategory, TUint aMasterKey, RProperty::TType aType, TUint aSlaveKeySlot) : |
|
754 CTestProgram(KSecurityName), iCategory(aCategory), iMasterKey(aMasterKey), |
|
755 iSlaveKeySlot(aSlaveKeySlot), iType(aType) |
|
756 { |
|
757 } |
|
758 |
|
759 _LIT(KSecuritySlavePath, "t_prop_sec.exe"); |
|
760 |
|
761 void CPropSecurity::Run(TUint aCount) |
|
762 { |
|
763 for(TInt i=0; i<ECapability_Limit; i++) |
|
764 if(!PlatSec::IsCapabilityEnforced((TCapability)i)) |
|
765 { |
|
766 // System isn't configured with platform security enforced |
|
767 // so don't bother running tests |
|
768 return; |
|
769 } |
|
770 |
|
771 TArgs args; |
|
772 args.iCount = aCount; |
|
773 args.iCategory = iCategory; |
|
774 args.iMasterKey = iMasterKey; |
|
775 args.iSlaveKeySlot = iSlaveKeySlot; |
|
776 |
|
777 RProperty prop; |
|
778 |
|
779 TInt r = prop.Define(iCategory, iMasterKey, iType, KPassPolicy, KPassPolicy); |
|
780 TF_ERROR(r, r == KErrNone); |
|
781 |
|
782 Exec(KSecuritySlavePath, &args, sizeof(args)); |
|
783 |
|
784 Exec(_L("t_prop_define0.exe"), &args, sizeof(args)); |
|
785 Exec(_L("t_prop_define1.exe"), &args, sizeof(args)); |
|
786 Exec(_L("t_prop_define2.exe"), &args, sizeof(args)); |
|
787 Exec(_L("t_prop_define3.exe"), &args, sizeof(args)); |
|
788 |
|
789 r = prop.Delete(iCategory, iMasterKey); |
|
790 TF_ERROR(r, r == KErrNone); |
|
791 } |