--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/authenticationservices/authenticationserver/test/tauthcliserv/step_mgrclient.cpp Tue Nov 24 09:06:03 2009 +0200
@@ -0,0 +1,501 @@
+/*
+* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+#include <bautils.h>
+#include <s32file.h>
+#include <test/testexecutelog.h>
+
+#include "authserver/authmgrclient.h"
+#include "authserver/identity.h"
+#include "tauthcliservstep.h"
+
+using namespace AuthServer;
+
+class CRegActive : public CActive
+ {
+ public:
+ CRegActive(RAuthMgrClient& aClient, CIdentity*& aResult, TBool aStop = ETrue) :
+ CActive(EPriorityNormal),
+ iFirstTime(true),
+ iClient(aClient),
+ iResult(aResult),
+ iStop(aStop)
+ {
+ CActiveScheduler::Add(this);
+ }
+ void doReg()
+ {
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ iFirstTime = ETrue;
+ }
+ void DoCancel()
+ {
+ }
+ void RunL()
+ {
+ if (iFirstTime)
+ {
+ SetActive();
+ iStatus = KRequestPending;
+ iClient.RegisterIdentityL(iResult, _L("SOMENAME"), iStatus);
+ iFirstTime = false;
+ }
+ else
+ {
+ if (iStop)
+ {
+ CActiveScheduler::Stop();
+ }
+ iErr = iStatus.Int();
+ }
+ }
+ TBool iFirstTime;
+ RAuthMgrClient& iClient;
+ CIdentity*& iResult;
+ TBool iStop;
+ TInt iErr;
+ };
+
+class CTrainActive : public CActive
+ {
+ public:
+ CTrainActive(RAuthMgrClient& aClient, TBool aStop = ETrue) :
+ CActive(EPriorityNormal),
+ iClient(aClient),
+ iResult(EFail),
+ iRunCount(0),
+ iStop(aStop)
+ {
+ CActiveScheduler::Add(this);
+ }
+ void doTrain()
+ {
+
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ iRunCount = 0;
+ }
+ void DoCancel()
+ {
+ }
+ void RunL()
+ {
+ iErr = iStatus.Int();
+ if (iStatus.Int() != KErrNone)
+ {
+ }
+ switch (iRunCount)
+ {
+ case 0:
+ iStatus = KRequestPending;
+ iAe = AuthExpr(0x10274104);
+ iId = 0;
+
+ iClient.AuthenticateL(*iAe, 10, EFalse, EFalse, iId, iStatus);
+ SetActive();
+
+ break;
+ case 1:
+ delete iAe;
+ delete iId;
+ iStatus = KRequestPending;
+ iClient.TrainPlugin(22, 0x10274104, iStatus);
+ SetActive();
+
+ break;
+ case 2:
+ iResult = iStatus.Int() == KErrNone ? EPass : EFail;
+ iErr = iStatus.Int();
+ if (iStop)
+ {
+ CActiveScheduler::Stop();
+ }
+
+ break;
+ default:
+ iResult = EFail;
+
+ if (iStop)
+ {
+ CActiveScheduler::Stop();
+ }
+ }
+ ++iRunCount;
+ }
+ RAuthMgrClient& iClient;
+ TVerdict iResult;
+ TInt iRunCount;
+ CAuthExpression* iAe;
+ CIdentity* iId;
+ TBool iStop;
+ TInt iErr;
+ };
+
+class CTrainActive2 : public CActive
+ {
+ public:
+ CTrainActive2(RAuthMgrClient& aClient, TBool aStop = ETrue) :
+ CActive(EPriorityNormal),
+ iClient(aClient),
+ iRunCount(0),
+ iStop(aStop)
+ {
+ CActiveScheduler::Add(this);
+ }
+ void doTrain()
+ {
+ SetActive();
+ iClient.TrainPlugin(22, 0x10274105, iStatus);
+ }
+ void DoCancel()
+ {
+ }
+ void RunL()
+ {
+ iErr = iStatus.Int();
+ if (iStop)
+ {
+ CActiveScheduler::Stop();
+ }
+ }
+
+ RAuthMgrClient& iClient;
+ TInt iRunCount;
+ CAuthExpression* iAe;
+ CIdentity* iId;
+ TBool iStop;
+ TInt iErr;
+ };
+
+class CCancelActive : public CActive
+ {
+ public:
+ CCancelActive(RAuthMgrClient& aClient) :
+ CActive(EPriorityNormal),
+ iClient(aClient),
+ iResult(EFail),
+ iRunCount(0)
+ {
+ CActiveScheduler::Add(this);
+ }
+ void doIdCancel()
+ {
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ iMode = 1;
+ iRunCount = 0;
+ }
+ void doRegCancel()
+ {
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ iMode = 2;
+ iRunCount = 0;
+ }
+ void doTrainCancel()
+ {
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ iMode = 0;
+ iRunCount = 0;
+ }
+ void DoCancel()
+ {
+ }
+ void RunL()
+ {
+ if (iStatus.Int() != KErrNone)
+ {
+ //RDebug::Printf("CCancelActive error: %d", iStatus.Int());
+ }
+ switch (iRunCount)
+ {
+ case 0:
+ iStatus = KRequestPending;
+ iAe = AuthExpr(0x10274105);
+ iId = 0;
+ switch (iMode)
+ {
+ case 2:
+ iClient.RegisterIdentityL(iId, _L("RegCancelID"), iStatus);
+ break;
+ case 1:
+ iClient.AuthenticateL(*iAe, 0, EFalse, ETrue, iId, iStatus);
+ break;
+ case 0:
+ iClient.TrainPlugin(22, 0x10274105, iStatus);
+ break;
+ }
+ SetActive();
+ User::After(1000000);
+ iClient.Cancel();
+
+ break;
+ case 1:
+ //iStatus = KRequestPending;
+
+ delete iAe;
+ delete iId;
+ //SetActive();
+
+ //break;
+ case 2:
+ iResult = iStatus.Int() == KErrCancel ? EPass : EFail;
+ CActiveScheduler::Stop();
+
+ break;
+ default:
+ iResult = EFail;
+ CActiveScheduler::Stop();
+ }
+ ++iRunCount;
+ }
+ RAuthMgrClient& iClient;
+ TVerdict iResult;
+ TInt iRunCount;
+ CAuthExpression* iAe;
+ CIdentity* iId;
+ TInt iMode;
+ };
+
+
+CTStepMgrClient::CTStepMgrClient()
+ {
+ SetTestStepName(KTStepMgrClient);
+ }
+
+
+TBool CTStepMgrClient::TestMultiRegisterL(RAuthMgrClient& client)
+ {
+ CIdentity* result = 0;
+ CRegActive active(client, result);
+
+ CIdentity* result2 = 0;
+ RAuthMgrClient client2;
+ User::LeaveIfError(client2.Connect());
+ CleanupClosePushL(client2);
+
+ CRegActive active2(client2, result2, EFalse);
+
+ active.doReg();
+ active2.doReg();
+
+ CActiveScheduler::Start();
+
+ TEST(active.iErr == KErrNone);
+ TEST(active2.iErr == KErrServerBusy);
+
+ delete result;
+ delete result2;
+ CleanupStack::PopAndDestroy(&client2);
+ return ETrue;
+
+ }
+
+TBool CTStepMgrClient::TestRegister(RAuthMgrClient& client)
+ {
+ CIdentity* result = 0;
+ CRegActive active(client, result);
+
+ active.doReg();
+
+ CActiveScheduler::Start();
+ if (result == 0)
+ {
+ return EFalse;
+ }
+
+ INFO_PRINTF3(_L("Id = %d , KeyLength = %d\n"), result->Id(), result->Key().KeyData().Size());
+ delete result;
+ result = 0;
+ return ETrue;
+ }
+
+TBool CTStepMgrClient::TestMultiTrainL(RAuthMgrClient& client)
+ {
+ CTrainActive2 active(client);
+ active.doTrain();
+
+ RAuthMgrClient client2;
+ User::LeaveIfError(client2.Connect());
+ CleanupClosePushL(client2);
+
+ CTrainActive2 active2(client2, EFalse);
+ active2.doTrain();
+
+ CActiveScheduler::Start();
+
+ TEST(active.iErr == KErrAuthServPluginCancelled); // blocking plugin returns
+ // cancelled if left to
+ // complete
+ TEST(active2.iErr == KErrServerBusy);
+
+ CleanupStack::PopAndDestroy(&client2);
+ INFO_PRINTF3(_L("Training Result (%d,%d)\n"),
+ active.iErr,
+ active2.iErr);
+
+ return true;
+ }
+
+
+TBool CTStepMgrClient::TestTrain(RAuthMgrClient& client)
+ {
+ CTrainActive active(client);
+ active.doTrain();
+ CActiveScheduler::Start();
+ INFO_PRINTF2(_L("Training Result = %d\n"), active.iResult == EPass);
+ return active.iResult == EPass;
+ }
+
+TBool CTStepMgrClient::TestCancellation(RAuthMgrClient& client)
+ {
+ CCancelActive active(client);
+
+ active.doTrainCancel();
+ CActiveScheduler::Start();
+ TEST(active.iResult == EPass);
+ INFO_PRINTF2(_L("Training Cancel Result = %d\n"), active.iResult == EPass);
+
+ active.doTrainCancel();
+ CActiveScheduler::Start();
+ TEST(active.iResult == EPass);
+ INFO_PRINTF2(_L("Training Cancel Result = %d\n"), active.iResult == EPass);
+
+ active.doTrainCancel();
+ CActiveScheduler::Start();
+ TEST(active.iResult == EPass);
+ INFO_PRINTF2(_L("Training Cancel Result = %d\n"), active.iResult == EPass);
+
+ //User::After(5000000);
+ active.doIdCancel();
+ CActiveScheduler::Start();
+ TEST(active.iResult == EPass);
+ INFO_PRINTF2(_L("Id Cancel Result = %d\n"), active.iResult == EPass);
+
+ active.doIdCancel();
+ CActiveScheduler::Start();
+ TEST(active.iResult == EPass);
+ INFO_PRINTF2(_L("Id Cancel Result = %d\n"), active.iResult == EPass);
+
+ active.doRegCancel();
+ CActiveScheduler::Start();
+ TEST(active.iResult == EPass);
+ INFO_PRINTF2(_L("Registration Cancel Result = %d\n"), active.iResult == EPass);
+
+ return active.iResult == EPass;
+ }
+
+TVerdict CTStepMgrClient::doTestStepL()
+ {
+ TInt r = 0;
+
+ if (TestStepResult() != EPass)
+ {
+ INFO_PRINTF1(_L("Previous step failed"));
+
+ return TestStepResult();
+ }
+
+
+ WaitForServerToReleaseDb();
+
+
+ TDriveUnit sysDrive (RFs::GetSystemDrive());
+ TDriveName sysDriveName (sysDrive.Name());
+
+ _LIT(KDbSrcFile ,"\\authdb0.db");
+ TBuf<64> dbSrcFileName (sysDriveName);
+ dbSrcFileName.Append(KDbSrcFile);
+
+ TBuf<128> dbName(KDbName);
+ dbName[0] = 'A' + sysDrive;
+
+ r = BaflUtils::CopyFile(iFs, dbSrcFileName, dbName);
+
+ INFO_PRINTF2(_L("File copy returned %d"), r);
+
+ User::LeaveIfError(r);
+
+
+
+ __UHEAP_MARK;
+ SetTestStepResult(EPass);
+
+ CActiveScheduler::Install(iActSchd);
+
+
+ RAuthMgrClient mgrclient;
+ User::LeaveIfError(mgrclient.Connect());
+ CleanupClosePushL(mgrclient);
+
+ mgrclient.RemoveIdentityL(2);
+
+
+ RIdentityIdArray ids;
+ mgrclient.IdentitiesL(ids);
+ CleanupClosePushL(ids);
+
+ TESTL(ids.Count() == 3);
+
+ // ensure each expected identity occurs once.
+ // (This technique is simple but doesn't generalise.)
+ TInt sum = 0;
+ for (TInt i = 0; i < 3; ++i)
+ {
+ TIdentityId id = ids[i];
+ TESTL(id == 1 || id == 3 || id == 22);
+ sum += id;
+ }
+ TESTL(sum == 1 + 3 + 22);
+
+ CleanupStack::PopAndDestroy(&ids);
+
+ TEST(TestRegister(mgrclient));
+
+ mgrclient.IdentitiesL(ids);
+ CleanupClosePushL(ids);
+ TEST(ids.Count() == 4);
+ CleanupStack::PopAndDestroy(&ids);
+
+ TEST(TestTrain(mgrclient));
+
+ INFO_PRINTF1(_L("Testing cancellation"));
+ TEST(TestCancellation(mgrclient));
+
+ INFO_PRINTF1(_L("Testing simultaneous registrations are blocked"));
+ TEST(TestMultiRegisterL(mgrclient));
+
+ INFO_PRINTF1(_L("Testing simultaneous trainings are blocked"));
+ TestMultiTrainL(mgrclient);
+
+ // Last plugin can't be removed
+ TRAPD(err, mgrclient.ForgetPluginL(22,0x10274104));
+ TEST(err == KErrAuthServCanNotRemoveLastPlugin);
+
+ CleanupStack::PopAndDestroy(1, &mgrclient);
+
+ __UHEAP_MARKEND;
+ return EPass;
+ }