--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/multimodetsy/test/Te_LoopBack/Te_LoopBackSCHAT.CPP Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,415 @@
+// Copyright (c) 1997-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:
+// This file implements the management of strings for matching between the chat buffer (also
+// called the history buffer) and the chat strings. The chat buffer is a single buffer that
+// contains information that has been written to the test harness from the tsy. The chat
+// strings are the expected strings specified in the scripting language (in the RxEvents).
+// The expected or chat strings must match the strings received from the TSY.
+// This file also includes the logic to support the use of buffer markers to be associated with
+// the history buffer and the Chat strings. Essentially, these buffer markers delimit the
+// range of addresses in the history buffer where data associated with a particular command
+// could be found. The buffer marker structure only contains one address and uses the current
+// last character address as it's other delimeter.
+//
+//
+
+/**
+ @file
+*/
+
+#include "Te_LoopBackATSTD.H"
+#include "Te_LoopBackSCHAT.H"
+#include "Te_LoopBackSLOGGER.H"
+
+CCommChatString* CCommChatString::NewL(const TDesC8& aDes, TBool aIsFolded)
+/**
+ * 2 Phase Constructor
+ *
+ * This method creates a CCommChatString instance. After newing the necessary, it
+ * pushes the chat string pointer onto the stack. Then it calls it's second stage
+ * constructor (in this case the CreateL method), passing the parameters passed to
+ * this method.
+ *
+ * @param aDes references the descriptor that contains the string.
+ * @param aIsFolded a boolean that indicates the "foldedness" of this string.
+ *
+ * @leave This function will leave if the system is out of memory or unable
+ * to allocate the amount of memory requested.
+ *
+ * @return A pointer to the newly created CCommChatString
+ */
+ {
+ CCommChatString* cs = new (ELeave) CCommChatString;
+ CleanupStack::PushL(cs);
+ cs->CreateL(aDes, aIsFolded);
+ CleanupStack::Pop();
+ return cs;
+ }
+
+CCommChatString::CCommChatString()
+/**
+ * This method is the standard constructor for the class CCommChatString.
+ */
+ {
+ __DECLARE_NAME(_S("CCommChatString"));
+ }
+
+CCommChatString::~CCommChatString()
+/**
+ * This method is the standard destructor. It frees the memory allocated in the CreateL
+ * method during construction.
+ *
+ * @return None.
+ */
+ {
+ User::Free(iString);
+ }
+
+void CCommChatString::CreateL(const TDesC8& aDes, TBool aIsFolded)
+/**
+ * Second Phase of Constructor
+ *
+ * This method is used as the second phase of the constructor for the CComChatString
+ * class. It allocates heap memory as specified by the passed in descriptor's length.
+ * Then, the string located in the descriptor is copied into the newly allocated memory.
+ * The member data iLastChar is initialized to point to the last byte copied. The member
+ * data iIsFolded is initialized to the passed parameter.
+ *
+ * @param aDes The descriptor containing the string data specified by the caller.
+ * @param aIsFolded A boolean indicating whether or not the string is folded.
+ *
+ * @leave Leaves via User::AllocL if memory can not be allocated.
+ */
+ {
+ iIsFolded = aIsFolded;
+ iString = (TText8*) User::AllocL(aDes.Length());
+ iLastChar = (iString+aDes.Length())-1;
+ Mem::Copy(iString, (TUint8*)aDes.Ptr(), aDes.Length());
+ }
+
+//
+// CCommChatter
+//
+CCommChatter::CCommChatter(MCommChatNotify* aNotify, TInt aPriority)
+ : CTimer(aPriority), iNotify(aNotify)
+/**
+ * The constructor for the CCommChatter class. It adds the active object to the active
+ * scheduler of the current thread and initializes member data elements.
+ *
+ * @param aNotify A pointer to the mixin class object associated with this object. This
+ * information is stored in the iNotify member.
+ * @param aPriority The priority which is assigned to the timer this class derives from CTimer.
+ */
+ {
+ __DECLARE_NAME(_S("CCommChatter"));
+ CActiveScheduler::Add(this);
+ iList.SetOffset(_FOFF(CCommChatString,iLink));
+ iMarkWrapCnt=0;
+ }
+
+CCommChatter::~CCommChatter()
+/**
+ * The standard destructor associated with the CCommChatter class. This method uses the
+ * DeleteAllAndStop method to free resources saved in the CCommChatter object. Then it frees
+ * the buffer created with CCommChatter.
+ *
+ * @return None
+ */
+ {
+ DeleteAllAndStop();
+ User::Free(iBuffer);
+ }
+
+void CCommChatter::CreateL(TInt aBufSize)
+/**
+ * This method is really the second stage constructor for the CCommChatter class, though it is
+ * not called by the typical CCommChatter::NewL() method. The CCommChatter class is typically
+ * created by another method (in the regression test case harness it is created in the
+ * CATIO::ConstructL() method), then this method is called. This method allocates a buffer and
+ * constructs the timer derived from CTimer in this class. The member data iBuffer, iBufferEnd,
+ * and iMarkWrapCnt are initialized.
+ *
+ * @param aBufSize The size of the buffer to be created with this object.
+ *
+ * @leave This method can Leave via User::AllocL if memory is not available.
+ */
+ {
+ CTimer::ConstructL();
+ iBuffer = (TText8*)User::AllocL(aBufSize);
+ iBufferEnd = (iBuffer+aBufSize)-1;
+ ClearHistory();
+ iMarkWrapCnt=0;
+ }
+
+void CCommChatter::ClearHistory()
+//
+// Empty history
+//
+/**
+ * This method resets the history of the CCommChatter buffer in the object. It simply clears
+ * the iCount and initializes the iLastChar member to iBuffer (the beginning of the buffer).
+ *
+ * @return None.
+ */
+ {
+ iLastChar = iBuffer;
+ iCount = 0;
+ }
+
+void CCommChatter::AddCharL(TText8 aChar)
+//
+// Add a character to the history buffer
+// Scan all strings to find any matches that may
+// be completed.
+//
+/**
+ * This method adds a single character to the history buffer and then scans all stored
+ * strings to find any matches that may have been completed because this character has
+ * been added. The function deals with folded characters during the search. Note that
+ * the routine first checks to see if the last character in the stored string matches
+ * the input character. This reduces the number of invocations of the string match
+ * functions.
+ *
+ * @param aChar The character to add to the buffer.
+ * @leave This method can leave via the ChatStringMatchL call.
+ */
+ {
+ // Add char to buffer
+ if (++iLastChar>iBufferEnd)
+ {
+ iLastChar = iBuffer;
+ iMarkWrapCnt++;
+ }
+ *iLastChar = aChar;
+ ++iCount;
+
+ TText8 fchar = (TText8)User::Fold(aChar);
+
+ // Scan for matching last character
+ CCommChatString* cs;
+ TDblQueIter<CCommChatString> iter(iList);
+
+ while (cs = iter++, cs!=NULL)
+ {
+ if (cs->IsFolded()
+ ? (User::Fold(cs->LastChar())==fchar && MatchF(cs))
+ : (cs->LastChar()==aChar && Match(cs)))
+ {
+ iNotify->ChatStringMatchL(cs);
+ cs = iter; // In case user removed cs;
+ }
+ }
+ }
+
+TBool CCommChatter::Match(const CCommChatString* aString) const
+//
+// Match a chat sgring against the history buffer
+// (Case sensitive)
+//
+/**
+ * This method matchs a chat string against the history buffer in a case sensitive (unfolded)
+ * manner. First the length of the two strings is compared. Then the actual content of the
+ * strings is compared.
+ *
+ * @param aString A constant pointer to the chat string.
+ *
+ * @return ETrue if strings match, EFalse if they do not.
+ */
+ {
+ const TText8* s = aString->Ptr();
+ const TText8* sp = aString->EndPtr();
+ const TText8* bp = iLastChar;
+
+ if (iCount<aString->Length())
+ return EFalse;
+
+ while (*bp==*sp && sp>=s)
+ {
+ --sp;
+ if (--bp<iBuffer)
+ bp = iBufferEnd;
+ }
+
+ return sp<s;
+ }
+
+TBool CCommChatter::MatchF(const CCommChatString* aString) const
+//
+// Match a folded chat string against the history buffer.
+// (Case insensitive)
+//
+
+/**
+ * This method matchs a chat string against the history buffer in a case insensitive or folded
+ * manner. First the length of the two strings is compared. Then the actual content of the
+ * strings is compared.
+ *
+ * @param aString A constant pointer to the chat string.
+ *
+ * @return ETrue if strings match, EFalse if they do not.
+ */
+ {
+ const TText8* s = aString->Ptr();
+ const TText8* sp = aString->EndPtr();
+ const TText8* bp = iLastChar;
+ if (iCount<aString->Length())
+ return EFalse;
+
+ while (User::Fold(*bp)==User::Fold(*sp) && sp>=s)
+ {
+ --sp;
+ if (--bp<iBuffer)
+ bp = iBufferEnd;
+ }
+ return sp<s;
+ }
+
+void CCommChatter::GetChatBufferMarker(TInputBufferMark& aBufferMarker)
+/**
+ * This method sets up a buffer marker structure. It saves the current last character
+ * location and notes the wrap state of the buffer.
+ *
+ * @param aBufferMarker A reference to a buffer marker structure.
+ * Is modified with the current location of iLastChar and a wrap flag.
+ * @return None
+ */
+ {
+ aBufferMarker.iMarkChar=iLastChar;
+ if(++aBufferMarker.iMarkChar>iBufferEnd)
+ {
+ aBufferMarker.iMarkWrap=iMarkWrapCnt+1;
+ aBufferMarker.iMarkChar=iBuffer;
+ }
+ else
+ aBufferMarker.iMarkWrap=iMarkWrapCnt;
+ }
+
+TPtrC8 CCommChatter::GetChatBufferLC(TInputBufferMark& aBufferMarker)
+/**
+ * This method deals with extracting data from the Chat or History Buffer and returning it
+ * to the caller. The data that is extracted from the buffer marker to the current last
+ * character in the buffer. This method creates a new HBufC8 object and returns a pointer
+ * to that descriptor. This method deals properly with a wrapped history buffer.
+ *
+ * @param aBufferMarker is a reference to a buffer marker structure that has been
+ * previously initialized. This buffer marker structure limits the range of the
+ * history buffer which must be copied/examined to find the relevant data.
+ * @leave Leaves if error processing buffer between the mark and the current
+ * last character.
+ * @return TPtrC8 pointer to a newly created HBufC8 which contains the iRxBuffer
+ * contents between the marker and the current last character. Data that
+ * is of interest to this completion has been copied from the general
+ * receive buffer to this buffer.
+ */
+ {
+ TText8* markChar=aBufferMarker.iMarkChar;
+ if(iMarkWrapCnt==aBufferMarker.iMarkWrap)
+ {
+ __ASSERT_ALWAYS(iLastChar>markChar,User::Leave(KErrGeneral)); // Internal Error
+ HBufC8* buffer=HBufC8::NewLC(iLastChar-markChar+1);
+ TPtr8 ptr(buffer->Des());
+ ptr.Copy(markChar,iLastChar-markChar+1);
+ return ptr;
+ }
+ else
+ {
+ if((iLastChar>markChar)||(iMarkWrapCnt>aBufferMarker.iMarkWrap+1))
+ User::Leave(KErrGeneral); // Data Lost
+ HBufC8* buffer=HBufC8::NewLC(KChatBufferSize-(markChar-iLastChar)+1);
+ TPtr8 ptr(buffer->Des());
+ ptr.Copy(TPtrC8(markChar,iBufferEnd-markChar+1));
+ ptr.Append(TPtrC8(iBuffer,iLastChar-iBuffer+1));
+ return ptr;
+ }
+ }
+
+void CCommChatter::RunL()
+/**
+ * This is the RunL associated with the CTimer inherited by the CCommChatter class. This
+ * RunL simply processess a timeout.
+ *
+ * @return None
+ */
+ {
+ iNotify->ChatTimeout();
+ }
+
+CCommChatString* CCommChatter::AddString(const TDesC8& aString)
+/**
+ * This method adds a string to the stored chat strings. It creates a new chat string object
+ * and adds it to the list of outstanding chat strings.
+ *
+ * @param aString This is a constant TDesC8 reference that is used to create the new string.
+ * @return A pointer to the newly created CCommChatString object.
+ */
+ {
+ CCommChatString* chatString=NULL;
+ TRAP_IGNORE(chatString=CCommChatString::NewL(aString,ETrue)); // trap but ignore leaves
+ iList.AddLast(*chatString);
+ return chatString;
+ }
+
+void CCommChatter::RemoveString(CCommChatString* aString)
+/**
+ * This method removes a string from the stored chat strings. It dequeues the string from the
+ * list of stored chat strings but does not delete the object.
+ *
+ * @param aString A pointer to a CCommChatString
+ * @return None
+ */ {
+ aString->iLink.Deque();
+ }
+
+void CCommChatter::DeleteAllAndStop()
+/**
+ * This method stops the outstanding CTimer and removes all of the outstanding chat strings
+ * from the chat string list and deletes them.
+ *
+ * @return None.
+ */
+ {
+ StopTimer();
+ CCommChatString* cs;
+ while (!iList.IsEmpty())
+ {
+ cs = iList.First();
+ RemoveString(cs);
+ delete cs;
+ }
+ }
+
+void CCommChatter::StartTimer(const TTimeIntervalMicroSeconds32 aTimeout)
+/**
+ * This method starts the timer associated with the CCommChatter class. This timer
+ * triggers after a specific interval of time. This is a one shot timer.
+ *
+ * @param aTimeout The interval in micro-seconds before the timer should trigger.
+ * @return None
+ */
+ {
+ if (IsActive())
+ Cancel();
+ After(aTimeout);
+ }
+
+void CCommChatter::StopTimer()
+/**
+ * This method simply stops the outstanding timer for the CCommChatter class. This timer
+ * is implemented via an active object by the CTimer class.
+ *
+ * @return None
+ */
+ {
+ Cancel();
+ }