--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/contentmgmt/cafstreamingsupport/test/tscaf/source/tkeystreamsink.cpp Mon Mar 15 12:46:43 2010 +0200
@@ -0,0 +1,289 @@
+// Copyright (c) 2007-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:
+// Implements the Key Stream Sink usage tests.
+//
+//
+
+#include "tkeystreamsink.h"
+
+using namespace StreamAccess;
+
+// CScafKeyStreamSink
+
+CScafKeyStreamSink::CScafKeyStreamSink(CScafServer& aParent)
+/**
+ Constructor.
+ */
+ : CScafStep(aParent)
+ {
+ SetTestStepName(KScafKeyStreamSinkStep);
+ }
+
+CScafKeyStreamSink::~CScafKeyStreamSink()
+/**
+ Destructor.
+ */
+ {
+ //empty
+ }
+
+TVerdict CScafKeyStreamSink::doTestL()
+ {
+ TPtrC privatePath;
+
+ if(iDecoderConfigurationArray[0]->iPrivateFolderPath.Length())
+ {
+ privatePath.Set(iDecoderConfigurationArray[0]->iPrivateFolderPath);
+ }
+ else
+ {
+ privatePath.Set(KStaPrivateFolder());
+ }
+
+ //Ensure pre-conditions
+ CleanAgentsPrivateFolderL(privatePath);
+
+ //First copy the service protected RO into the test agent's private directory
+ CopyFile2AgentsPrivateFolderL(iParent.Fs(), KServiceProtectedRo(), privatePath);
+
+ _LIT8(KPlainString,"aplainstring");
+ CSraRightsObject* ro = GetRightsObjectLC(KServiceProtectedRo(),privatePath);
+ //Encrypt the string with the encryption key
+ //Since encryption is not tested here, the encrypted key is
+ //created by appending the encryption key.
+ TBuf8<50> encryptedStr;
+ encryptedStr.Append(KPlainString);
+ encryptedStr.Append(*ro->Key());
+ CleanupStack::PopAndDestroy(ro);
+
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
+ //Create an SDP document object and set the created key stream field object
+ CSdpDocument* sdpDoc = CreateSdpDocumentLC();
+ //Create an SDP key stream field object with an attribute requiring the service protected RO
+ CSdpMediaField* sdp = CreateSdpLC(0);
+ AddMediaFieldL(*sdpDoc, sdp);
+ CleanupStack::Pop(sdp);
+
+ //Create a test key stream sink
+ _LIT(KKeySinkOutputFileName,"testkeysstreamsink.dat");
+ CKeyStreamSink* sink = CreateKeyStreamSinkLC(KKeySinkOutputFileName, privatePath);
+
+ CTestKeyStreamDecoderBase* decoder = NULL;
+
+ if(iDecoderConfigurationArray[0]->iSingleProcessAgent)
+ {
+ // Single Process Stream Agent
+ decoder = CTestSingleProcessKeyStreamDecoder::NewL(*sink, *sdp, *sdpDoc);
+ }
+ else
+ {
+ // Client/Server Stream Agent
+ decoder = CTestAgentKeyStreamDecoder::NewL(*sink, *sdp, *sdpDoc);
+ }
+
+ CleanupStack::PushL(decoder);
+
+ //Send the encrypted string
+ decoder->SendKeyStreamL(encryptedStr);
+
+ //Compare the output key with the original one
+ HBufC* fOutput = GetFullPathLC(privatePath, KKeySinkOutputFileName);
+
+ RFile fOutputKey;
+ User::LeaveIfError(fOutputKey.Open(iParent.Fs(), *fOutput, EFileRead));
+ CleanupStack::PopAndDestroy(fOutput);
+ CleanupClosePushL(fOutputKey);
+ TBuf8<50> decryptedKey;
+ User::LeaveIfError(fOutputKey.Read(decryptedKey));
+
+ if(decryptedKey.Compare(KPlainString))
+ {
+ SetTestStepResult(EFail);
+ }
+
+ CleanupStack::PopAndDestroy(4, sdpDoc); // fOutputKey, decoder, sink, sdpDoc
+#endif
+
+
+ return TestStepResult();
+ }
+
+
+//CScafConcurrentKeyStreamSinks
+
+CScafConcurrentKeyStreamSinks::CScafConcurrentKeyStreamSinks(CScafServer& aParent)
+/**
+ Constructor.
+ */
+ : CScafStep(aParent)
+ {
+ SetTestStepName(KScafConcurrentKeyStreamSinksStep);
+ }
+
+CScafConcurrentKeyStreamSinks::~CScafConcurrentKeyStreamSinks()
+/**
+ Destructor.
+ */
+ {
+ //empty
+ }
+
+TVerdict CScafConcurrentKeyStreamSinks::doTestL()
+ {
+ TPtrC privatePathA;
+
+ if(iDecoderConfigurationArray[0]->iPrivateFolderPath.Length())
+ {
+ privatePathA.Set(iDecoderConfigurationArray[0]->iPrivateFolderPath);
+ }
+ else
+ {
+ privatePathA.Set(KStaPrivateFolder());
+ }
+
+ TPtrC privatePathB;
+
+ if(iDecoderConfigurationArray[1]->iPrivateFolderPath.Length())
+ {
+ privatePathB.Set(iDecoderConfigurationArray[1]->iPrivateFolderPath);
+ }
+ else
+ {
+ privatePathB.Set(KStaPrivateFolder());
+ }
+
+ //Ensure pre-conditions
+ CleanAgentsPrivateFolderL(privatePathA);
+ CleanAgentsPrivateFolderL(privatePathB);
+
+ //First copy the service protected RO into the private directories of each stream agent
+ CopyFile2AgentsPrivateFolderL(iParent.Fs(), KServiceProtectedRo(), privatePathA);
+ CopyFile2AgentsPrivateFolderL(iParent.Fs(), KServiceProtectedRo(), privatePathB);
+
+ //Secondly copy the program protected RO into the private directories of each stream agent
+ CopyFile2AgentsPrivateFolderL(iParent.Fs(), KProgramProtectedRo(), privatePathA);
+ CopyFile2AgentsPrivateFolderL(iParent.Fs(), KProgramProtectedRo(), privatePathB);
+
+#ifdef INTERNALLY_ENABLE_UPWARD_DEPENDENCY
+ //Create an SDP document object and set the created key stream field object for each decoder
+ CSdpDocument* sdpDoc = CreateSdpDocumentLC();
+
+ //Create a SDP object for RO-A
+ TInt sdpNum = 0;
+ CSdpMediaField* sdpA = CreateSdpLC(sdpNum++);
+ AddMediaFieldL(*sdpDoc, sdpA);
+ CleanupStack::Pop(sdpA);
+
+ //Create a SDP object for RO-B
+ CSdpMediaField* sdpB = CreateSdpLC(sdpNum);
+ AddMediaFieldL(*sdpDoc, sdpB);
+ CleanupStack::Pop(sdpB);
+
+ //Create a test key stream sink for test key stream decoder A
+ _LIT(KKeySinkOutputFileNameA,"testkeysstreamsinkA.dat");
+ CKeyStreamSink* sinkA = CreateKeyStreamSinkLC(KKeySinkOutputFileNameA,privatePathA);
+
+
+ //Create test key stream decoder A
+ CTestKeyStreamDecoderBase* decoderA = NULL;
+
+ if(iDecoderConfigurationArray[0]->iSingleProcessAgent)
+ {
+ // Single Process Stream Agent
+ decoderA = CTestSingleProcessKeyStreamDecoder::NewL(*sinkA, *sdpA, *sdpDoc);
+ }
+ else
+ {
+ // Client/Server Stream Agent
+ decoderA = CTestAgentKeyStreamDecoder::NewL(*sinkA, *sdpA, *sdpDoc);
+ }
+
+ CleanupStack::PushL(decoderA);
+
+ //Create a test key stream sink for test key stream decoder B
+ _LIT(KKeySinkOutputFileNameB,"testkeysstreamsinkB.dat");
+ CKeyStreamSink* sinkB = CreateKeyStreamSinkLC(KKeySinkOutputFileNameB,privatePathB);
+
+ //Create test key stream decoder B
+ CTestKeyStreamDecoderBase* decoderB = NULL;
+
+ if(iDecoderConfigurationArray[1]->iSingleProcessAgent)
+ {
+ // Single Process Stream Agent
+ decoderB = CTestSingleProcessKeyStreamDecoder::NewL(*sinkB, *sdpB, *sdpDoc);
+ }
+ else
+ {
+ // Client/Server Stream Agent
+ decoderB = CTestAgentKeyStreamDecoder::NewL(*sinkB, *sdpB, *sdpDoc);
+ }
+
+ CleanupStack::PushL(decoderB);
+
+ _LIT8(KPlainStringA,"plainstringA");
+ CSraRightsObject* roA = GetRightsObjectLC(KServiceProtectedRo,privatePathA);
+ //Encrypt the plain string A
+ TBuf8<50> encryptedStr;
+ encryptedStr.Append(KPlainStringA);
+ encryptedStr.Append(*roA->Key());
+ CleanupStack::PopAndDestroy(roA);
+ //Send the encrypted string A
+ decoderA->SendKeyStreamL(encryptedStr);
+
+ _LIT8(KPlainStringB,"plainstringB");
+ CSraRightsObject* roB = GetRightsObjectLC(KProgramProtectedRo,privatePathB);
+ //Encrypt the plain string B
+ encryptedStr.Zero();
+ encryptedStr.Append(KPlainStringB);
+ encryptedStr.Append(*roB->Key());
+ CleanupStack::PopAndDestroy(roB);
+ //Send the encrypted string B
+ decoderB->SendKeyStreamL(encryptedStr);
+
+ //Compare the output key file A with the original one
+ HBufC* fOutputA = GetFullPathLC(privatePathA, KKeySinkOutputFileNameA);
+ RFile fOutputKey;
+ User::LeaveIfError(fOutputKey.Open(iParent.Fs(), *fOutputA, EFileRead));
+ CleanupStack::PopAndDestroy(fOutputA);
+ CleanupClosePushL(fOutputKey);
+ TBuf8<50> decryptedKey;
+ User::LeaveIfError(fOutputKey.Read(decryptedKey));
+ CleanupStack::PopAndDestroy(&fOutputKey);
+
+ if(decryptedKey.Compare(KPlainStringA))
+ {
+ SetTestStepResult(EFail);
+ }
+
+ //Compare the output key file B with the original one
+ HBufC* fOutputB = GetFullPathLC(privatePathB, KKeySinkOutputFileNameB);
+ User::LeaveIfError(fOutputKey.Open(iParent.Fs(), *fOutputB, EFileRead));
+ CleanupStack::PopAndDestroy(fOutputB);
+ CleanupClosePushL(fOutputKey);
+ decryptedKey.Zero();
+ User::LeaveIfError(fOutputKey.Read(decryptedKey));
+ CleanupStack::PopAndDestroy(&fOutputKey);
+
+ if(decryptedKey.Compare(KPlainStringB))
+ {
+ SetTestStepResult(EFail);
+ }
+
+ //Release allocated resources
+ CleanupStack::PopAndDestroy(2, sinkB); //< decoderB, sink B
+ CleanupStack::PopAndDestroy(2, sinkA); //< decoderA, sinkA
+ CleanupStack::PopAndDestroy(sdpDoc); //< sdpDoc
+#endif
+ return TestStepResult();
+ }