|
1 /* |
|
2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the License "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #ifndef TAUTHCLISERVSTEP_H |
|
20 #define TAUTHCLISERVSTEP_H |
|
21 |
|
22 #include <e32cmn.h> |
|
23 #include <ct/rcpointerarray.h> |
|
24 #include <ecom/ecom.h> |
|
25 |
|
26 #include <test/testexecutestepbase.h> |
|
27 #include <test/testexecutelog.h> |
|
28 |
|
29 #include "tauthcliserv.h" |
|
30 |
|
31 #ifndef __INIPARSER_H__ |
|
32 #include <cinidata.h> |
|
33 #endif // __INIPARSER_H__ |
|
34 |
|
35 // publicly available include file |
|
36 #include "authserver_client.h" |
|
37 #include <authserver/authplugininterface.h> |
|
38 |
|
39 // these tests use some information which is normally |
|
40 // only visible to the server, or to the client DLL. |
|
41 |
|
42 #include "authserveripc.h" |
|
43 #include "authdb.h" |
|
44 #include "transientkey.h" |
|
45 #include "transientkeyinfo.h" |
|
46 #include "evaluator.h" |
|
47 |
|
48 // load test plugin data |
|
49 #include "../tauthplugins/consts.h" |
|
50 |
|
51 using AuthServer::TIdentityId; |
|
52 using AuthServer::TPluginId; |
|
53 using AuthServer::TAuthPluginType; |
|
54 using AuthServer::TAuthTrainingStatus; |
|
55 using AuthServer::CAuthExpression; |
|
56 using AuthServer::CAuthExpressionImpl; |
|
57 using AuthServer::TAuthExpressionWrapper; |
|
58 using AuthServer::CEvaluator; |
|
59 using AuthServer::CPluginDesc; |
|
60 using AuthServer::RAuthClient; |
|
61 |
|
62 // Authserver name |
|
63 _LIT(KAuthServerName, "!AuthServer"); |
|
64 |
|
65 _LIT(KTStepCreateDb,"CREATEDB"); |
|
66 _LIT(KTStepClient, "CLIENT"); |
|
67 _LIT(KTStepMgrClient, "MGRCLIENT"); |
|
68 _LIT(KTStepFirstStart, "FIRSTSTART"); |
|
69 |
|
70 _LIT(KTStepAuthExprBuild, "AuthExprBuild"); |
|
71 _LIT(KTStepBadExtAuthExpr, "AuthExprBadAuthExt"); |
|
72 _LIT(KTStepAuthExprHighVer, "AuthExprHighVer"); |
|
73 _LIT(KTStepAuthExprEval, "AuthExprEval"); |
|
74 |
|
75 // debug-mode tests for client-side panicks |
|
76 _LIT(KTStepAuthExprTypePnc, "AuthExprTypePanic"); |
|
77 _LIT(KTStepAuthExprTypePncBadLeft, "AuthExprTypePanicBadLeft"); |
|
78 _LIT(KTStepAuthExprTypePncBadRight, "AuthExprTypePanicBadRight"); |
|
79 |
|
80 // These are used in the RemoveExistingDbL() function |
|
81 // applying to DBs used by tPinAuthPlugin |
|
82 _LIT(KPlugin3100File, "\\tAuth\\tAuthSvr\\testdata\\Pin11113100Db.ini"); |
|
83 _LIT(KPlugin3101File, "\\tAuth\\tAuthSvr\\testdata\\Pin11113101Db.ini"); |
|
84 _LIT(KPlugin3102File, "\\tAuth\\tAuthSvr\\testdata\\Pin11113102Db.ini"); |
|
85 _LIT(KAuthSvrPolicyFile, "\\tAuth\\tAuthSvr\\testdata\\AuthSvrPolicy.ini"); |
|
86 _LIT(KPinDbTag, "Identity&PinValues"); |
|
87 _LIT(KTotalDbTag, "AllUserID&PinValues"); |
|
88 _LIT(KInitPinDatabaseValue, ","); |
|
89 _LIT(KDisplayMessage, "DisplayMessage"); |
|
90 |
|
91 #define KNumPlugins 8 |
|
92 |
|
93 const TInt KTestPluginId22 = 0x10274104; |
|
94 const TInt KTestPluginBlocking = 0x10274105; |
|
95 const TInt KTestPluginIdInactive = 0x10274106; |
|
96 const TInt KTestPluginIdUnknown = 0x10274107; |
|
97 |
|
98 |
|
99 class CTAuthcliservStepBase : public CTestStep |
|
100 { |
|
101 protected: |
|
102 CTAuthcliservStepBase() {} |
|
103 virtual ~CTAuthcliservStepBase(); |
|
104 virtual TVerdict doTestStepPreambleL() |
|
105 { |
|
106 iFs.Connect(); |
|
107 |
|
108 CreatePlugins(); |
|
109 CreateKeyInfo(); |
|
110 |
|
111 return TestStepResult(); |
|
112 } |
|
113 virtual TVerdict doTestStepPostambleL() |
|
114 { |
|
115 iFs.Close(); |
|
116 return TestStepResult(); |
|
117 } |
|
118 |
|
119 inline void CreatePlugins(); |
|
120 inline void CreateKeyInfo(); |
|
121 HBufC* GetNameLC(TInt i); |
|
122 |
|
123 void PluginData(AuthServer::TIdentityId aId, |
|
124 AuthServer::TPluginId aPlugin, |
|
125 TPtr8 aDes) |
|
126 { |
|
127 aDes.Fill(aId*aPlugin); |
|
128 } |
|
129 |
|
130 void WaitForServerToReleaseDb(); |
|
131 void RemoveExistingDbL(); |
|
132 //Utility function allowing text INI file parsing abilities |
|
133 //Section name unspecified |
|
134 TInt writeToNamedConfig(const TDesC &aFileName, const TDesC &aKeyName,const TPtrC &aResult); |
|
135 |
|
136 |
|
137 protected: |
|
138 RFs iFs; |
|
139 |
|
140 |
|
141 AuthServer::CPluginDesc* iPlugins[KNumPlugins]; |
|
142 AuthServer::CTransientKeyInfo* iId1Keys[KNumPlugins]; |
|
143 AuthServer::CTransientKeyInfo* iId2Keys[KNumPlugins]; |
|
144 AuthServer::CTransientKeyInfo* iId3Keys[KNumPlugins]; |
|
145 }; |
|
146 |
|
147 inline CTAuthcliservStepBase::~CTAuthcliservStepBase() |
|
148 { |
|
149 for (TInt i = 0 ; i < KNumPlugins ; ++i) |
|
150 { |
|
151 delete iPlugins[i]; |
|
152 delete iId1Keys[i]; |
|
153 delete iId2Keys[i]; |
|
154 delete iId3Keys[i]; |
|
155 } |
|
156 } |
|
157 |
|
158 class CTStepActSch : public CTAuthcliservStepBase |
|
159 /** |
|
160 This abstract subclass of CTAuthcliservStepBase |
|
161 overrides the doTestStep(Pre|Post)ambleL functions |
|
162 from CTestBase to allocate and free an active |
|
163 scheduler. |
|
164 |
|
165 The scheduler is stored in the protected iActSchd |
|
166 variable. This class does not start or stop the |
|
167 scheduler. |
|
168 */ |
|
169 { |
|
170 private: |
|
171 // override CTestStep |
|
172 inline virtual TVerdict doTestStepPreambleL(); |
|
173 inline virtual TVerdict doTestStepPostambleL(); |
|
174 |
|
175 protected: |
|
176 /** The active scheduler which subclasses can use. */ |
|
177 CActiveScheduler* iActSchd; |
|
178 }; |
|
179 |
|
180 |
|
181 |
|
182 inline TVerdict CTStepActSch::doTestStepPreambleL() |
|
183 /** |
|
184 Override CTestStep by allocating an active |
|
185 scheduler which is available to the subclass. |
|
186 |
|
187 @return This test step's result, |
|
188 which isn't actually used |
|
189 by ThreadStepExecutionL. |
|
190 */ |
|
191 { |
|
192 CTAuthcliservStepBase::doTestStepPreambleL(); |
|
193 iActSchd = new(ELeave) CActiveScheduler; |
|
194 return TestStepResult(); |
|
195 } |
|
196 |
|
197 |
|
198 inline TVerdict CTStepActSch::doTestStepPostambleL() |
|
199 /** |
|
200 Override CTestStep by deleting the active |
|
201 scheduler which allocated in doTestStepPreambleL. |
|
202 |
|
203 @return This test step's result, |
|
204 which isn't actually used |
|
205 by ThreadStepExecutionL. |
|
206 */ |
|
207 { |
|
208 CTAuthcliservStepBase::doTestStepPostambleL(); |
|
209 delete iActSchd; |
|
210 return TestStepResult(); |
|
211 } |
|
212 |
|
213 |
|
214 class CTStepClient : public CTStepActSch |
|
215 { |
|
216 public: |
|
217 CTStepClient(); |
|
218 virtual TVerdict doTestStepL(); |
|
219 TBool TestAuthenticate(AuthServer::RAuthClient& client); |
|
220 TBool TestAuthenticate2(AuthServer::RAuthClient& client); |
|
221 TBool TestAuthenticate3(AuthServer::RAuthClient& client); |
|
222 TBool TestAuthenticateFail(AuthServer::RAuthClient& client); |
|
223 |
|
224 |
|
225 |
|
226 private: |
|
227 void GetDescriptionsFromEComL(RPointerArray<CPluginDesc>& aDescs); |
|
228 |
|
229 void TestIdentitiesL(); |
|
230 void GetIdentitiesLC(RArray<TIdentityId>& aIds); |
|
231 void AddIdentityL(TIdentityId aIdentityId, const TDesC& aDesc); |
|
232 void TestIdentityL(TIdentityId aIdentityId, const TDesC& aExpDesc); |
|
233 void TestSetIdentityStrL(); |
|
234 |
|
235 void TestClientPluginListsL(); |
|
236 void SetSeenCountsL(const RCPointerArray<const CPluginDesc>& aPlugins); |
|
237 void TestTypedPluginsL(RAuthClient& aClient, TAuthPluginType aPluginType); |
|
238 void TestTrainedPluginsL(); |
|
239 void PrepareTrainedPluginsL(); |
|
240 void TestActivePluginsL(RAuthClient& aClient); |
|
241 TBool TestAuthenticateL(); |
|
242 TBool TestMultiAuthL(); |
|
243 |
|
244 private: |
|
245 RArray<TUid> iPluginIds; |
|
246 }; |
|
247 |
|
248 class CTStepMgrClient : public CTStepActSch |
|
249 { |
|
250 public: |
|
251 CTStepMgrClient(); |
|
252 virtual TVerdict doTestStepL(); |
|
253 TBool TestRegister(AuthServer::RAuthMgrClient& client); |
|
254 TBool TestMultiRegisterL(AuthServer::RAuthMgrClient& client); |
|
255 |
|
256 TBool TestMultiTrainL(AuthServer::RAuthMgrClient& client); |
|
257 TBool TestTrain(AuthServer::RAuthMgrClient& client); |
|
258 TBool TestCancellation(AuthServer::RAuthMgrClient& client); |
|
259 }; |
|
260 |
|
261 class CTStepFirstStart : public CTAuthcliservStepBase |
|
262 { |
|
263 public: |
|
264 CTStepFirstStart(); |
|
265 virtual TVerdict doTestStepL(); |
|
266 }; |
|
267 |
|
268 |
|
269 inline HBufC* CTAuthcliservStepBase::GetNameLC(TInt id) |
|
270 { |
|
271 _LIT(nameTmpl, "Plugin_%d"); |
|
272 HBufC* name = HBufC::NewLC(15); |
|
273 name->Des().Format(nameTmpl, id); |
|
274 return name; |
|
275 } |
|
276 |
|
277 inline void CTAuthcliservStepBase::CreatePlugins() |
|
278 { |
|
279 using namespace AuthServer; |
|
280 |
|
281 const TAuthPluginType types[KNumPlugins] |
|
282 = { EAuthBiometric, EAuthToken, EAuthKnowledge, |
|
283 EAuthBiometric, EAuthToken, EAuthKnowledge, |
|
284 EAuthToken, EAuthKnowledge |
|
285 }; |
|
286 const TAuthTrainingStatus training[KNumPlugins] |
|
287 = { EAuthUntrained, EAuthTrained, EAuthFullyTrained, |
|
288 EAuthUntrained, EAuthTrained, EAuthFullyTrained, |
|
289 EAuthTrained, EAuthFullyTrained |
|
290 }; |
|
291 |
|
292 |
|
293 for (TInt i = 0 ; i < KNumPlugins ; ++i) |
|
294 { |
|
295 HBufC* name = GetNameLC(i); |
|
296 |
|
297 iPlugins[i] = CPluginDesc::NewL(i, |
|
298 *name, |
|
299 types[i], |
|
300 training[i], |
|
301 i*10000, |
|
302 i, |
|
303 i*4); |
|
304 CleanupStack::PopAndDestroy(name); |
|
305 } |
|
306 } |
|
307 inline void CTAuthcliservStepBase::CreateKeyInfo() |
|
308 { |
|
309 using namespace AuthServer; |
|
310 |
|
311 CProtectionKey* protKey1 = CProtectionKey::NewLC(8); |
|
312 CProtectionKey* protKey2 = CProtectionKey::NewLC(8); |
|
313 CProtectionKey* protKey3 = CProtectionKey::NewLC(8); |
|
314 |
|
315 HBufC8* data = HBufC8::NewLC(4); |
|
316 |
|
317 for (TInt plugin = 0 ; plugin < KNumPlugins ; ++plugin) |
|
318 { |
|
319 CTransientKey* transient = 0; |
|
320 // id 1 |
|
321 iId1Keys[plugin] = CTransientKeyInfo::NewL(plugin); |
|
322 PluginData(1, plugin, data->Des()); |
|
323 transient = iId1Keys[plugin]->CreateTransientKeyL(data->Des()); |
|
324 CEncryptedProtectionKey* epKey1 = |
|
325 transient->EncryptL(*protKey1); |
|
326 delete transient; |
|
327 iId1Keys[plugin]->SetEncryptedProtectionKeyL(epKey1); |
|
328 // id 2 |
|
329 PluginData(2, plugin, data->Des()); |
|
330 iId2Keys[plugin] = CTransientKeyInfo::NewL(plugin); |
|
331 transient = iId2Keys[plugin]->CreateTransientKeyL(data->Des()); |
|
332 CEncryptedProtectionKey* epKey2 = |
|
333 transient->EncryptL(*protKey2); |
|
334 delete transient; |
|
335 iId2Keys[plugin]->SetEncryptedProtectionKeyL(epKey2); |
|
336 // id 3 |
|
337 PluginData(3, plugin, data->Des()); |
|
338 iId3Keys[plugin] = CTransientKeyInfo::NewL(plugin); |
|
339 transient = iId3Keys[plugin]->CreateTransientKeyL(data->Des()); |
|
340 CEncryptedProtectionKey* epKey3 = |
|
341 transient->EncryptL(*protKey3); |
|
342 delete transient; |
|
343 iId3Keys[plugin]->SetEncryptedProtectionKeyL(epKey3); |
|
344 } |
|
345 CleanupStack::Pop(4, protKey1); |
|
346 } |
|
347 |
|
348 // -------- Authentication expression tests -------- |
|
349 |
|
350 class CTStepAuthExprBuild : public CTAuthcliservStepBase |
|
351 /** |
|
352 This test step ensures that complex authentication |
|
353 expressions can be constructed, or fail cleanly in OOM. |
|
354 */ |
|
355 { |
|
356 public: |
|
357 CTStepAuthExprBuild(); |
|
358 |
|
359 // implement CTestStep |
|
360 virtual TVerdict doTestStepL(); |
|
361 |
|
362 private: |
|
363 void RunTestsL(); |
|
364 void TestExprLD( |
|
365 void (CTStepAuthExprBuild::*aTestFuncL)(AuthServer::CAuthExpression*), |
|
366 AuthServer::CAuthExpression* aExpr); |
|
367 |
|
368 #ifdef AUTH_EXPR_BINARY_OPS |
|
369 inline void OpTestExprLD( |
|
370 void (CTStepAuthExprBuild::*aTestFuncL)(AuthServer::CAuthExpression*), |
|
371 AuthServer::CAuthExpression* aExpr) |
|
372 { |
|
373 TestExprLD(aTestFuncL, aExpr); |
|
374 } |
|
375 #else |
|
376 // this isn't an empty inline because don't want compiler |
|
377 // to build expression with binary operators. |
|
378 #define OpTestExprLD(___f, ___expr) |
|
379 #endif |
|
380 |
|
381 void TestSimpleExprL(); |
|
382 void TestPluginIdL(AuthServer::CAuthExpression* aExpr); |
|
383 void TestPluginTypeL(AuthServer::CAuthExpression* aExpr); |
|
384 |
|
385 void TestSimpleExprCombsConsL(); |
|
386 void TestTypeAndTypeL(AuthServer::CAuthExpression* aExpr); |
|
387 void TestTypeOrTypeL(AuthServer::CAuthExpression* aExpr); |
|
388 void TestIdAndTypeL(AuthServer::CAuthExpression* aExpr); |
|
389 void TestTypeAndIdL(AuthServer::CAuthExpression* aExpr); |
|
390 void TestIdAndIdL(AuthServer::CAuthExpression* aExpr); |
|
391 |
|
392 void TestComplexExprCombsConsL(); |
|
393 void TestAndAndL(AuthServer::CAuthExpression* aExpr); |
|
394 void TestAndOrL(AuthServer::CAuthExpression* aExpr); |
|
395 void TestOrAndL(AuthServer::CAuthExpression* aExpr); |
|
396 void TestOrOrL(AuthServer::CAuthExpression* aExpr); |
|
397 |
|
398 void TestFailedCombsL(); |
|
399 void TestCorruptPersistL(); |
|
400 }; |
|
401 |
|
402 class CTStepAuthExprTypePnc : public CTAuthcliservStepBase |
|
403 /** |
|
404 This test step ensures the client is panicked when |
|
405 they attempt to retrieve the type of a corrupt expression. |
|
406 */ |
|
407 { |
|
408 public: |
|
409 CTStepAuthExprTypePnc(); |
|
410 |
|
411 // implement CTestStep |
|
412 virtual TVerdict doTestStepL(); |
|
413 }; |
|
414 |
|
415 class CTStepAuthExprTypePncBadLeft : public CTAuthcliservStepBase |
|
416 /** |
|
417 This test step ensures the client is panicked when |
|
418 they attempt to retrieve the type of a expression, |
|
419 where the left subtree is corrupt. |
|
420 */ |
|
421 { |
|
422 public: |
|
423 CTStepAuthExprTypePncBadLeft(); |
|
424 |
|
425 // implement CTestStep |
|
426 virtual TVerdict doTestStepL(); |
|
427 }; |
|
428 |
|
429 class CTStepAuthExprTypePncBadRight : public CTAuthcliservStepBase |
|
430 /** |
|
431 This test step ensures the client is panicked when |
|
432 they attempt to retrieve the type of a expression, |
|
433 where the right subtree is corrupt. |
|
434 */ |
|
435 { |
|
436 public: |
|
437 CTStepAuthExprTypePncBadRight(); |
|
438 |
|
439 // implement CTestStep |
|
440 virtual TVerdict doTestStepL(); |
|
441 }; |
|
442 |
|
443 class CTStepAuthExprHighVer : public CTAuthcliservStepBase |
|
444 /** |
|
445 This step tests sending an unsupported authentication |
|
446 expression to the server. |
|
447 |
|
448 The server should fail the request. |
|
449 */ |
|
450 { |
|
451 public: |
|
452 CTStepAuthExprHighVer(); |
|
453 |
|
454 // implement CTestStep |
|
455 virtual TVerdict doTestStepL(); |
|
456 }; |
|
457 |
|
458 class CTStepBadExtAuthExpr : public CTAuthcliservStepBase |
|
459 /** |
|
460 This step tests trying to authenticate a server with |
|
461 an invalid authentication expression. |
|
462 |
|
463 The client code should be panicked. |
|
464 */ |
|
465 { |
|
466 public: |
|
467 CTStepBadExtAuthExpr(); |
|
468 |
|
469 // implement CTestStep |
|
470 virtual TVerdict doTestStepL(); |
|
471 }; |
|
472 |
|
473 |
|
474 class TTestPluginInterface : public AuthServer::MEvaluatorPluginInterface |
|
475 /** |
|
476 This implementation records which calls were made |
|
477 to the interface, so the test code can test the |
|
478 evaluator made the right calls in the right order. |
|
479 */ |
|
480 { |
|
481 public: |
|
482 virtual void Evaluate(TPluginId aPluginId, TIdentityId& aIdentity, |
|
483 CAuthExpressionImpl::TType aType, TRequestStatus& aStatus); |
|
484 virtual void Evaluate(TAuthPluginType aPluginType, TIdentityId& aIdentity, |
|
485 CAuthExpressionImpl::TType aType, TRequestStatus& aStatus); |
|
486 virtual void CancelEvaluate() {} ; |
|
487 public: |
|
488 class TCallEntry |
|
489 { |
|
490 public: |
|
491 inline TCallEntry(TPluginId aPluginId) |
|
492 : iCallType(CAuthExpressionImpl::EPluginId), |
|
493 iPluginId(aPluginId) |
|
494 { |
|
495 // empty. |
|
496 } |
|
497 |
|
498 inline TCallEntry(TAuthPluginType aPluginType) |
|
499 : iCallType(CAuthExpressionImpl::EPluginType), |
|
500 iPluginType(aPluginType) |
|
501 { |
|
502 // empty. |
|
503 } |
|
504 |
|
505 bool operator==(const TCallEntry& aRhs) const; |
|
506 |
|
507 public: |
|
508 /** Type of call - ID or plugin type. */ |
|
509 CAuthExpressionImpl::TType iCallType; |
|
510 |
|
511 union |
|
512 { |
|
513 TPluginId iPluginId; |
|
514 TAuthPluginType iPluginType; |
|
515 }; |
|
516 }; |
|
517 |
|
518 /** |
|
519 The sequence of Evaluate requests which have been received |
|
520 by this object. This is a non-standard case of a T class |
|
521 owning resources. These resources are freed by CLaunchEval |
|
522 because it is not worth making this an R-class or C-class |
|
523 for test code. |
|
524 */ |
|
525 RArray<TCallEntry> iCallLog; |
|
526 }; |
|
527 |
|
528 class TTestClientInterface : public AuthServer::MEvaluatorClientInterface |
|
529 /** |
|
530 This implementation records whether the evaluation |
|
531 succeeded or failed, so the test code can check the |
|
532 result. |
|
533 */ |
|
534 { |
|
535 public: |
|
536 virtual void EvaluationSucceeded(TIdentityId aIdentityId); |
|
537 virtual void EvaluationFailed(TInt aReason); |
|
538 |
|
539 public: |
|
540 enum TCompletionMode {ENone = 0x10, ESucceeded, EFailed}; |
|
541 TCompletionMode iMode; |
|
542 /** This is valid iff iMode == ESucceeded. */ |
|
543 TIdentityId iIdentityId; |
|
544 /** This is valid iff iMode == EFailed. */ |
|
545 TInt iReason; |
|
546 }; |
|
547 |
|
548 |
|
549 class CLaunchEval : public CActive |
|
550 /** |
|
551 Active object which launches an evaluation. |
|
552 |
|
553 This object is defined so there is one pending |
|
554 object when the active scheduler is started. |
|
555 */ |
|
556 { |
|
557 public: |
|
558 static CLaunchEval* NewL(); |
|
559 virtual ~CLaunchEval(); |
|
560 |
|
561 void Evaluate(const CAuthExpression* aExpr); |
|
562 |
|
563 private: |
|
564 CLaunchEval(); |
|
565 void ConstructL(); |
|
566 void ResetInterfaces(); |
|
567 |
|
568 // implement CActive |
|
569 virtual void RunL(); |
|
570 virtual void DoCancel(); |
|
571 |
|
572 public: |
|
573 TTestClientInterface iClientInterface; |
|
574 TTestPluginInterface iPluginInterface; |
|
575 |
|
576 private: |
|
577 /** |
|
578 Expression to evaluate. This is set for each |
|
579 call to Evaluate. |
|
580 */ |
|
581 const CAuthExpression* iExpr; |
|
582 |
|
583 /** Evaluator, which is allocated at construction. */ |
|
584 CEvaluator* iEval; |
|
585 }; |
|
586 |
|
587 |
|
588 class CTStepAuthExprEval : public CTStepActSch |
|
589 /** |
|
590 This step tests trying to authenticate a server with |
|
591 an invalid authentication expression. |
|
592 |
|
593 The client code should be panicked. |
|
594 */ |
|
595 { |
|
596 public: |
|
597 CTStepAuthExprEval(); |
|
598 |
|
599 // implement CTestStep |
|
600 virtual TVerdict doTestStepL(); |
|
601 |
|
602 private: |
|
603 void TestEvalCreateL(); |
|
604 void TestEvalSimpleL(); |
|
605 void TestEvalAndL(); |
|
606 void TestEvalOrL(); |
|
607 void TestEvalResultL( |
|
608 CLaunchEval* aLaunchEval, TIdentityId aIdentityId, |
|
609 const TTestPluginInterface::TCallEntry* aExpEntries, TInt aEntryCount); |
|
610 |
|
611 void TestRPNReallocL(); |
|
612 void RunOomTestsL( |
|
613 TAuthExpressionWrapper (*aAllocator)(TInt), |
|
614 TIdentityId aExpectedIdentity, TInt aInitDepth); |
|
615 }; |
|
616 |
|
617 const TPluginId KTestPluginId0 = 'PID0'; |
|
618 const TPluginId KTestPluginId1 = 'PID1'; |
|
619 const TPluginId KTestPluginId2 = 'PID2'; |
|
620 const TPluginId KTestPluginUnknown = 'UNKW'; |
|
621 |
|
622 // These constants are defined to provide short |
|
623 // names for readability only. |
|
624 |
|
625 const CAuthExpressionImpl::TType KAnd = CAuthExpressionImpl::EAnd; |
|
626 const CAuthExpressionImpl::TType KOr = CAuthExpressionImpl::EOr; |
|
627 const CAuthExpressionImpl::TType KPluginId = CAuthExpressionImpl::EPluginId; |
|
628 const CAuthExpressionImpl::TType KPluginType = CAuthExpressionImpl::EPluginType; |
|
629 #endif /* TAUTHCLISERVSTEP_H */ |