--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/smsprotocols/smsstack/test/EmsTestUtils.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,353 @@
+// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "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 "EmsTestUtils.h"
+#include "EMSInformationElement.h"
+#include "Gsmumsg.h"
+#include "gsmubuf.h"
+#include "EMSFormatIE.h"
+#include "EMSSoundIE.h"
+#include "EMSAnimationIE.h"
+#include "EMSPictureIE.h"
+#include "EMSUserPromptIE.h"
+#include "EMSObjectDistributionIE.h"
+#include <fbs.h>
+
+EXPORT_C TBool EmsTestUtils::CompareEmsIE(const CEmsInformationElement& aLeft, const CEmsInformationElement& aRight)
+ {
+ TBool retVal = EFalse;
+
+ // make sure the types, start position, and length are the same
+ if ((aLeft.Identifier() == aRight.Identifier()) &&
+ (aLeft.StartPosition() == aRight.StartPosition()) &&
+ (aLeft.Length() == aRight.Length()))
+ {
+ switch(aLeft.Identifier())
+ {
+ case CSmsInformationElement::ESmsEnhancedTextFormatting:
+ {
+ const CEmsFormatIE& leftIE = static_cast<const CEmsFormatIE&>(aLeft);
+ const CEmsFormatIE& rightIE = static_cast<const CEmsFormatIE&>(aRight);
+
+ retVal = (leftIE.FormatLength() == rightIE.FormatLength()) &&
+ (leftIE.Bold() == rightIE.Bold()) &&
+ (leftIE.Italic() == rightIE.Italic()) &&
+ (leftIE.Underline() == rightIE.Underline()) &&
+ (leftIE.Strikethrough() == rightIE.Strikethrough()) &&
+ (leftIE.Alignment() == rightIE.Alignment()) &&
+ (leftIE.FontSize() == rightIE.FontSize());
+ break;
+ }
+
+ case CSmsInformationElement::ESmsEnhancedPredefinedSound:
+ {
+ const CEmsPreDefSoundIE& leftIE = static_cast<const CEmsPreDefSoundIE&>(aLeft);
+ const CEmsPreDefSoundIE& rightIE = static_cast<const CEmsPreDefSoundIE&>(aRight);
+
+ retVal = (leftIE.PredefinedSound() == rightIE.PredefinedSound());
+ break;
+ }
+
+ case CSmsInformationElement::ESmsEnhancedUserDefinedSound:
+ {
+ const CEmsSoundIE& leftIE = static_cast<const CEmsSoundIE&>(aLeft);
+ const CEmsSoundIE& rightIE = static_cast<const CEmsSoundIE&>(aRight);
+
+ // returns true if the melodies are identical - ie if the
+ // compare returns 0 and hence the NOT operator
+ retVal = !(leftIE.Melody()->Compare(*rightIE.Melody()));
+ break;
+ }
+
+ case CSmsInformationElement::ESmsEnhancedPredefinedAnimation:
+ {
+ const CEmsPreDefAnimationIE& leftIE = static_cast<const CEmsPreDefAnimationIE&>(aLeft);
+ const CEmsPreDefAnimationIE& rightIE = static_cast<const CEmsPreDefAnimationIE&>(aRight);
+
+ retVal = (leftIE.Animation() == rightIE.Animation());
+ break;
+ }
+
+ case CSmsInformationElement::ESmsEnhancedLargePicture:
+ case CSmsInformationElement::ESmsEnhancedSmallPicture:
+ case CSmsInformationElement::ESmsEnhancedVariablePicture:
+ {
+ // for pictures, we can only compare the size, not the actual
+ // content
+ const CEmsPictureIE& leftIE = static_cast<const CEmsPictureIE&>(aLeft);
+ const CEmsPictureIE& rightIE = static_cast<const CEmsPictureIE&>(aRight);
+
+ retVal = (leftIE.SizeInPixels() == rightIE.SizeInPixels());
+ break;
+ }
+
+ case CSmsInformationElement::ESmsEnhancedUserPromptIndicator:
+ {
+ // for pictures, we can only compare the size, not the actual
+ // content
+ const CEmsUserPrompt& leftIE = static_cast<const CEmsUserPrompt&>(aLeft);
+ const CEmsUserPrompt& rightIE = static_cast<const CEmsUserPrompt&>(aRight);
+
+ retVal = (leftIE.ObjectCount() == rightIE.ObjectCount());
+ break;
+ }
+
+ case CSmsInformationElement::ESmsEnhancedODI:
+ {
+ const CEmsObjectDistribution& leftIE = static_cast<const CEmsObjectDistribution&>(aLeft);
+ const CEmsObjectDistribution& rightIE = static_cast<const CEmsObjectDistribution&>(aRight);
+
+ retVal = (leftIE.ObjectCount() == rightIE.ObjectCount()) && (leftIE.Forwarding() == rightIE.Forwarding());
+ break;
+ }
+
+ case CSmsInformationElement::ESmsEnhancedLargeAnimation:
+ case CSmsInformationElement::ESmsEnhancedSmallAnimation:
+ // for animations, we can't really compare anything
+ retVal = ETrue;
+ break;
+
+ default:
+ // if we come across an unknown ID, we just return false
+ retVal = EFalse;
+ break;
+ }
+ }
+ // if an ODI, start position doesn't have to match
+ else if (aLeft.Identifier() == CSmsInformationElement::ESmsEnhancedODI)
+ {
+ const CEmsObjectDistribution& leftIE = static_cast<const CEmsObjectDistribution&>(aLeft);
+ const CEmsObjectDistribution& rightIE = static_cast<const CEmsObjectDistribution&>(aRight);
+ retVal = (leftIE.ObjectCount() == rightIE.ObjectCount()) && (leftIE.Forwarding() == rightIE.Forwarding()) &&
+ (leftIE.Identifier() == rightIE.Identifier()) && (leftIE.Length() == rightIE.Length());
+ }
+
+ return retVal;
+ }
+
+
+EXPORT_C TBool EmsTestUtils::CompareEmsMsgL(const CSmsMessage& aLeft, const CSmsMessage& aRight)
+ {
+
+ TBool retVal = ETrue;
+
+ RSafeEmsArray leftAdjusted, rightAdjusted;
+ CleanupClosePushL(leftAdjusted);
+ CleanupClosePushL(rightAdjusted);
+
+ // Produce the adjusted ems objects so we can also compare
+ // segmented formatting objects
+ AdjustedEmsObjectsL(aLeft, leftAdjusted);
+ AdjustedEmsObjectsL(aRight, rightAdjusted);
+
+ // make sure the number of ems objects match
+ if (leftAdjusted.Count() != rightAdjusted.Count())
+ {
+ retVal = EFalse;
+ }
+ else
+ {
+ // for each EMS element in left, make sure we can find another
+ // element in right which matches completely
+ for (TInt i = 0; i < leftAdjusted.Count(); ++i)
+ {
+ TInt j;
+ for (j = 0; j < rightAdjusted.Count(); ++j)
+ {
+ if (CompareEmsIE(*leftAdjusted[i], *rightAdjusted[j]))
+ {
+ break;
+ }
+ }
+
+
+ // if j == right.Count(), this means we went through the entire
+ // array without finding a match. Hence we return EFalse
+ if (j == rightAdjusted.Count())
+ {
+ retVal = EFalse;
+ break;
+ }
+ }
+ }
+
+ // if EMS objects OK, then compare text as well
+ if (retVal)
+ {
+ HBufC* leftText = ExtractSmsTextLC(aLeft);
+ HBufC* rightText = ExtractSmsTextLC(aRight);
+
+ // do a text compare
+ retVal = (TPtr(leftText->Des()) == TPtr(rightText->Des()));
+
+ CleanupStack::PopAndDestroy(rightText);
+ CleanupStack::PopAndDestroy(leftText);
+ }
+
+ // pop the adjusted arrays
+ CleanupStack::PopAndDestroy(&rightAdjusted);
+ CleanupStack::PopAndDestroy(&leftAdjusted);
+
+ return retVal;
+ }
+
+EXPORT_C const CEmsInformationElement* EmsTestUtils::FindElementL(
+ const CSmsMessage& aMsg, CSmsInformationElement::TSmsInformationElementIdentifier aId)
+ {
+ const RPointerArray<const CEmsInformationElement>& arr =
+ aMsg.GetEMSInformationElementsL();
+
+ TInt cnt = arr.Count();
+ for (TInt i = 0; i < cnt; ++i)
+ {
+ if (arr[i]->Identifier() == aId)
+ return arr[i];
+ }
+ return NULL;
+ }
+
+EXPORT_C CEmsPictureIE* EmsTestUtils::CreatePictureL(TInt aIndex)
+ {
+ // path of the pictures
+ _LIT(KPicsMBM,"\\Ems\\pics.mbm");
+
+ // Create the picture object
+ CEmsPictureIE* picture = CreateEmsObjFromBitmapL<CEmsPictureIE>(KPicsMBM, aIndex);
+ return picture;
+ }
+
+EXPORT_C CEmsAnimationIE* EmsTestUtils::CreateAnimationL(TInt aIndex)
+ {
+ // path of the animations
+ _LIT(KAnimsMBM,"\\Ems\\anims.mbm");
+
+ CEmsAnimationIE* anim = CreateEmsObjFromBitmapL<CEmsAnimationIE>(KAnimsMBM, aIndex);
+ return anim;
+ }
+
+HBufC* EmsTestUtils::ExtractSmsTextLC(const CSmsMessage& aMsg)
+ {
+ const CSmsBufferBase& buffer = aMsg.Buffer();
+ TInt bufLen=buffer.Length();
+ HBufC* textBuf=HBufC::NewL(bufLen);
+ CleanupStack::PushL(textBuf);
+ TPtr textPtr(textBuf->Des());
+ buffer.Extract(textPtr,0,bufLen);
+ return textBuf;
+ }
+
+void EmsTestUtils::AdjustedEmsObjectsL(
+ const CSmsMessage& aMsg, RPointerArray<CEmsInformationElement>& aAdjusted)
+ {
+ // This will contain all the formatting objects of the message,
+ // but consolidated
+ RPointerArray<CEmsInformationElement> formatObjects(10);
+
+ const RPointerArray<const CEmsInformationElement>& emsObjects =
+ aMsg.GetEMSInformationElementsL();
+
+ // now go through the array in the message, and copy the objects
+ // if they are not format objects. Format objects go in a separate
+ // array for consolidation
+ TInt i;
+ for (i = 0; i < emsObjects.Count(); ++i)
+ {
+ if (emsObjects[i]->Identifier() != CSmsInformationElement::ESmsEnhancedTextFormatting)
+ {
+ aAdjusted.Append(emsObjects[i]->DuplicateL());
+ }
+ else
+ {
+ // otherwise, go through the format list and see if can be appended
+ // to an existing format object
+ const CEmsFormatIE* formatIE = static_cast<const CEmsFormatIE*>(emsObjects[i]);
+ TInt j;
+ for (j = 0; j < formatObjects.Count(); ++j)
+ {
+ // check if the start position of this element equals the
+ // startPos + length of the other format object
+ CEmsFormatIE* other = static_cast<CEmsFormatIE*>(formatObjects[j]);
+ if (formatIE->StartPosition() == other->StartPosition() + other->FormatLength() &&
+ formatIE->Bold() == other->Bold() &&
+ formatIE->Italic() == other->Italic() &&
+ formatIE->Underline() == other->Underline() &&
+ formatIE->Strikethrough() == other->Strikethrough() &&
+ formatIE->Alignment() == other->Alignment() &&
+ formatIE->FontSize() == other->FontSize())
+ {
+ // add the length
+ other->SetFormatLength(other->FormatLength() + formatIE->FormatLength());
+ break;
+ }
+ }
+
+ // if we have gone to the end without appending to another element,
+ // then clone the element and add it to the formatObjects array
+ if (j == formatObjects.Count())
+ {
+ formatObjects.Append(formatIE->DuplicateL());
+ }
+ }
+ }
+
+ // Now, move all elements from the format objects into the adjusted array
+ for (i = 0; i < formatObjects.Count(); ++i)
+ {
+ aAdjusted.Append(formatObjects[i]);
+ }
+
+ // make sure array memory has been deallocated
+ formatObjects.Close();
+ }
+
+template <class T>
+T* EmsTestUtils::CreateEmsObjFromBitmapL(const TDesC& aFilename, TInt32 aIndex)
+ {
+ _LIT(KTxtCDrive,"C:");
+ _LIT(KTxtZDrive,"Z:");
+
+ // startup bitmap server
+ FbsStartup();
+ User::LeaveIfError(RFbsSession::Connect());
+
+ // Given a particular filename, assumed to be in C:\ or Z:\, we load
+ // a bitmap from the given index. The bitmap is pushed onto the
+ // cleanup stack
+ CFbsBitmap* bmp;
+
+ TParse mbfn;
+ bmp = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL(bmp);
+
+ // load the indexed bitmap, first in drive C, then drive Z
+ mbfn.Set(aFilename, &KTxtCDrive, NULL);
+
+ // did it fail?
+ if (bmp->Load(mbfn.FullName(), aIndex))
+ {
+ // then try drive Z
+ mbfn.Set(aFilename, &KTxtZDrive, NULL);
+ User::LeaveIfError(bmp->Load(mbfn.FullName(), aIndex));
+ }
+
+ // if it succeeded, then create the appropriate type
+ T* obj = T::NewL(*bmp);
+ CleanupStack::PopAndDestroy(bmp);
+
+ RFbsSession::Disconnect();
+
+ return obj;
+ }