--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptomgmtlibs/cryptotokenfw/tframework/TestPlugin.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,293 @@
+/*
+* 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: 
+*
+*/
+
+
+
+
+/**
+ @file
+*/
+
+#include <e32base.h>
+#include <ecom.h>
+#include <implementationproxy.h>
+#include <ct.h>
+#include "MTestInterface.h"
+
+_LIT(KToken5Info, "Test Token 5");
+_LIT(KToken6Info, "Test Token 6");
+
+
+class CTestObject : public MTestObject
+	{
+public:
+	CTestObject(MCTToken& aToken) : MTestObject(aToken), iToken(aToken) {};
+
+	virtual const TDesC& Label() const;
+	virtual MCTToken& Token() const;
+	virtual TUid Type() const;
+	virtual TCTTokenObjectHandle Handle() const;
+
+private:
+	MCTToken& iToken;
+	};
+
+class CTestInterface : public MTestInterface
+	{
+public:
+	CTestInterface(const TDesC& aLabel, MCTToken& aToken)
+			: iLabel(aLabel), iToken(aToken) {};
+
+	virtual MCTToken& Token();
+
+	virtual const TDesC& Label();
+
+	MTestObject* ObjectL();
+
+private:
+	const TDesC& iLabel;
+	MCTToken& iToken;
+	};
+
+class CTestToken : public CBase, public MCTToken
+	{
+public:
+	CTestToken(const TDesC& aLabel, MCTTokenType& aTokenType);
+
+	virtual void DoGetInterface(TUid aRequiredInterface,
+							  MCTTokenInterface*& aReturnedInterface, 
+							  TRequestStatus& aStatus);
+	virtual TBool DoCancelGetInterface();
+
+	virtual const TDesC& Label();
+
+	virtual MCTTokenType& TokenType();
+
+	virtual TCTTokenHandle Handle();
+	virtual const TDesC& Information(TTokenInformation aRequiredInformation);
+protected:
+	virtual TInt& ReferenceCount();
+
+private:
+	MCTTokenType& iTokenType;
+	const TDesC& iLabel;
+	TInt iCount;
+	TBool iAsyncGetInterfaceRunning;
+	};
+
+CTestToken::CTestToken(const TDesC& aLabel, MCTTokenType& aTokenType)
+		: iTokenType(aTokenType), iLabel(aLabel)
+	{
+	}
+
+const TDesC& CTestToken::Label()
+	{
+	return iLabel;
+	}
+
+const TDesC& CTestToken::Information(TTokenInformation aRequiredInformation)
+	{
+	_LIT(KVersion, "The Ultimate Version");
+	_LIT(KSerial, "Serial No. 1");
+	_LIT(KManufacturer, "ACME Corporation");
+	switch (aRequiredInformation)
+		{
+	case EVersion:
+		return KVersion;
+	case ESerialNo:
+		return KSerial;
+	case EManufacturer:
+	default:
+		return KManufacturer;
+		}
+	}
+
+MCTTokenType& CTestToken::TokenType()
+	{
+	return iTokenType;
+	}
+
+MCTToken& CTestInterface::Token()
+	{
+	return iToken;
+	}
+const TDesC& CTestInterface::Label()
+	{
+	return iLabel;
+	}
+
+MTestObject* CTestInterface::ObjectL()
+	{
+	return new (ELeave) CTestObject(Token());
+	}
+
+const TDesC& CTestObject::Label() const
+	{
+	return Token().Label();
+	}
+
+MCTToken& CTestObject::Token() const
+	{
+	return iToken;
+	}
+
+TUid CTestObject::Type() const
+	{
+	TUid uid = {0};
+	return uid;
+	}
+
+TCTTokenObjectHandle CTestObject::Handle() const
+	{
+	return TCTTokenObjectHandle(Token().Handle(), 1);
+	}
+
+TCTTokenHandle CTestToken::Handle()
+	{
+	return TCTTokenHandle(TokenType().Type(), 1);
+	}
+
+void CTestToken::DoGetInterface(TUid aRequiredInterface,
+							  MCTTokenInterface*& aReturnedInterface, 
+							  TRequestStatus& aStatus)
+	{
+	// InterfaceC is returned. InterfaceB (actually anything else) is
+	// used to test async behaviour and never returns anything.
+	TUid uid = {0x101f4e52};
+	if (aRequiredInterface != uid)
+		{
+		iAsyncGetInterfaceRunning = ETrue;
+		return;
+		}
+	aReturnedInterface = new CTestInterface(iLabel, *this);
+	TRequestStatus* r = &aStatus;
+	if (aReturnedInterface)
+		User::RequestComplete(r, KErrNone);
+	else
+		User::RequestComplete(r, KErrNoMemory);
+	}
+
+TBool CTestToken::DoCancelGetInterface()
+	{
+	if (iAsyncGetInterfaceRunning)
+		{
+		iAsyncGetInterfaceRunning = EFalse;
+		return ETrue;
+		}
+	return EFalse;
+	}
+
+
+TInt& CTestToken::ReferenceCount()
+	{
+	return iCount;
+	}
+
+class CTokenTypeImplementation : public CCTTokenType
+	{
+public:
+	static CTokenTypeImplementation* NewL5();
+	static CTokenTypeImplementation* NewL6();
+
+	virtual void List(RCPointerArray<HBufC>& aTokens, 
+					  TRequestStatus& aStatus);
+	virtual void CancelList();
+	virtual void OpenToken(const TDesC& aTokenInfo, MCTToken*& aToken, 
+						   TRequestStatus& aStatus);
+	virtual void OpenToken(TCTTokenHandle aHandle, MCTToken*& aToken, 
+						   TRequestStatus& aStatus);
+	virtual void CancelOpenToken();
+
+	virtual ~CTokenTypeImplementation();
+protected:
+	HBufC* iMyInfo;
+	};
+
+void CTokenTypeImplementation::List(RCPointerArray<HBufC>& aTokens, 
+							   TRequestStatus& aStatus)
+	{
+	TRequestStatus* r = &aStatus;
+	HBufC* name = iMyInfo->Alloc();
+	if (name)
+		User::RequestComplete(r, aTokens.Append(name));
+	else
+		User::RequestComplete(r, KErrNoMemory);
+	}
+
+void CTokenTypeImplementation::CancelList()
+	{
+	}
+
+void CTokenTypeImplementation::OpenToken(const TDesC& /*aTokenInfo*/, MCTToken*& aToken,
+						   TRequestStatus& aStatus)
+	{
+	aToken = new CTestToken(*iMyInfo, *this);
+	TRequestStatus* r = &aStatus;
+	User::RequestComplete(r, KErrNone);
+	IncReferenceCount();
+	}
+
+void CTokenTypeImplementation::OpenToken(TCTTokenHandle /*aHandle*/,
+										 MCTToken*& aToken,
+										 TRequestStatus& aStatus)
+	{
+	aToken = new CTestToken(*iMyInfo, *this);
+	TRequestStatus* r = &aStatus;
+	User::RequestComplete(r, KErrNone);
+	IncReferenceCount();
+	}
+
+void CTokenTypeImplementation::CancelOpenToken()
+	{
+	}
+
+
+CTokenTypeImplementation::~CTokenTypeImplementation()
+	{
+	delete iMyInfo;
+	}
+
+CTokenTypeImplementation* CTokenTypeImplementation::NewL5()
+	{
+	CTokenTypeImplementation* that = new (ELeave) CTokenTypeImplementation;
+	CleanupStack::PushL(that);
+	that->iMyInfo = KToken5Info().AllocL();
+	CleanupStack::Pop(that);
+	return that;
+	}
+
+CTokenTypeImplementation* CTokenTypeImplementation::NewL6()
+	{
+	CTokenTypeImplementation* that = new (ELeave) CTokenTypeImplementation;
+	CleanupStack::PushL(that);
+	that->iMyInfo = KToken6Info().AllocL();
+	CleanupStack::Pop(that);
+	return that;
+	}
+
+const TImplementationProxy ImplementationTable[] = 
+	{
+		IMPLEMENTATION_PROXY_ENTRY(0x101F4E4D,	CTokenTypeImplementation::NewL5),
+		IMPLEMENTATION_PROXY_ENTRY(0x101F4E4C,	CTokenTypeImplementation::NewL6),
+	};
+
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+	{
+	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+	return ImplementationTable;
+	}