diff -r 000000000000 -r 72b543305e3a messagingappbase/smilparser/SMILdtd/tsrc/t_ScriptRunner.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/smilparser/SMILdtd/tsrc/t_ScriptRunner.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,2202 @@ +// Copyright (c) 2001-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: +// Parsing and Processing of script commands, to test the +// SMIL DOM classes. +// +// + + +#include "t_ScriptRunner.h" + + +_LIT(KLogFileName, "c:\\MsgTest\\SMIL_DOM\\SmilDomLog.txt"); + + +// Script Commands +_LIT(KCreateDOMtree, "createdomtree"); +_LIT(KDeleteDOMtree, "deletedomtree"); +_LIT(KCreate, "create"); +_LIT(KDeleteChild, "deletechild"); +_LIT(KParent, "parent"); +_LIT(KRootSmil, "rootsmil"); +_LIT(KFirstChild, "firstchild"); +_LIT(KLastChild, "lastchild"); +_LIT(KNextSibling, "nextsibling"); +_LIT(KPrevSibling, "prevsibling"); +_LIT(KFirst, "first"); +_LIT(KLast, "last"); +_LIT(KNext, "next"); +_LIT(KPrev, "prev"); +_LIT(KSetAtt, "setatt"); +_LIT(KGetAtt, "getatt"); +_LIT(KUnsetAtt, "unsetatt"); +_LIT(KLegalChildren, "legalchildren"); +_LIT(KSetId, "setid"); +_LIT(KGetId, "getid"); +_LIT(KRemoveId, "removeid"); + + +// Script Command Arguments: SMIL Elements (excluding 'smil') +_LIT(KA, "a"); +_LIT(KAnchor, "anchor"); +_LIT(KAnimation, "animation"); +_LIT(KArea, "area"); +_LIT(KAudio, "audio"); +_LIT(KBody, "body"); +_LIT(KHead, "head"); +_LIT(KImg, "img"); +_LIT(KLayout, "layout"); +_LIT(KMeta, "meta"); +_LIT(KPar, "par"); +_LIT(KRef, "ref"); +_LIT(KRegion, "region"); +_LIT(KRoot_layout, "root-layout"); +_LIT(KSeq, "seq"); +_LIT(KSwitch, "switch"); +_LIT(KText, "text"); +_LIT(KTextstream, "textstream"); +_LIT(KVideo, "video"); + + +// Other Script Command Arguments +_LIT(KAppend, "append"); +_LIT(KInsert, "insert"); +_LIT(KReplace, "replace"); + + +// Errors reported via the log file +_LIT(KNotSupported, "Not supported."); +_LIT(KInvalidChild, "Invalid child."); +_LIT(KCannotFindSpecifiedChild, "Cannot find specified child."); +_LIT(KReachedEnd_ElementInsertedAtStart, "Reached end of child list, element inserted at start of list."); +_LIT(KReachedEnd_NoChildReplaced, "Reached end of child list, no child has been replaced."); +_LIT(KReachedEnd_NoChildRemoved, "Reached end of child list, no child has been removed."); +_LIT(KAlreadyAtEndOfList, "Already at end of list."); +_LIT(KInvalidArgument, "Invalid argument."); +_LIT(KAttributeNotSet, "Attribute not set."); +_LIT(KElementHasLegalChildren, "Element has legal children."); +_LIT(KElementHasIllegalChildren, "Element has illegal children."); +_LIT(KUnrecognisedCommand, "Unrecognised command."); +_LIT(KUnrecognisedArgument, "Unrecognised argument."); +_LIT(KUnrecognisedElementType, "Unrecognised element type."); +_LIT(KNotABasicElt, "Error: Current element is not a BasicElt."); +_LIT(KNotOfSpecifiedType, "Error: Current element is not of the specified type."); + +// +// +// CScriptRunner +// + +CScriptRunner* CScriptRunner::NewL() + { + CScriptRunner* self = new (ELeave) CScriptRunner(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + + +CScriptRunner::~CScriptRunner() + { + delete iArgumentList; + delete iCurrentCommand; + delete iWriter; + delete iDOMtreeRoot; // This will delete the entire DOM tree + } + + +CScriptRunner::CScriptRunner() +: iCurrentCommand(NULL), iCurrentElement(NULL), iDOMtreeRoot(NULL) + { + } + + +void CScriptRunner::ConstructL() + { + iArgumentList = new (ELeave) CDesCArrayFlat(3); + iWriter = CTestDataWriter::NewL(KLogFileName); + } + + +// Extract the command, and any arguments, from the given string +void CScriptRunner::ParseL(const TDesC& aCommand) + { + // First, echo the command line to the log file + iWriter->WriteTest(aCommand); + + iArgumentList->Reset(); + delete iCurrentCommand; + iCurrentCommand = NULL; + + // Determine whether aCommand is a command, or a comment + if (aCommand.Length() >= 2 && aCommand[0] == '/' && aCommand[1] == '/') + { + // This is a comment + iCurrentCommand = NULL; + } + else // Extract the command, and any arguments + { + TInt commandIter = 0; + TInt commandStart = 0; + TBool inQuotes = EFalse; + while (commandIter <= aCommand.Length()) + { + TBool commandFound = EFalse; + + if (commandIter < aCommand.Length()) + { + if (aCommand[commandIter] == '"') + { + // We assume that quotes only occur at the beginning and end + // of arguments. Hence, if we've just found a new quote, we should + // not make it part of the argument. + if (!inQuotes) + { + inQuotes = ETrue; + commandStart++; + } + else + { + // Assume we've got to the end of the argument, and skip the + // following space. + commandFound = ETrue; + commandIter++; + } + } + else if ((aCommand[commandIter] == ' ') && (!inQuotes)) + { + commandFound = ETrue; + } + } + else + { + commandFound = ETrue; + } + + if (commandFound) + { + if (commandIter > commandStart) + { + // Command or argument found + TInt commandLength = commandIter - commandStart; + + // If the argument ended in quotes, modify the length to exclude them + if (inQuotes) + { + inQuotes = EFalse; + commandLength--; + } + + if (iCurrentCommand == NULL) + { + // This is a command + iCurrentCommand = HBufC::NewL(commandLength); + (*iCurrentCommand) = aCommand.Mid(commandStart, commandLength); + } + else + { + // This is a command argument + iArgumentList->AppendL(aCommand.Mid(commandStart, commandLength)); + } + + // Set the start of the next argument + commandStart = commandIter + 1; + } + } + + commandIter++; + } + } + + if (iCurrentCommand != NULL) + { + // Process the command + ProcessL(); + } + } + + +// Process the script command +void CScriptRunner::ProcessL() + { + if (iCurrentCommand->Compare(KCreateDOMtree) == 0) + { + // Create a new DOM tree (document + smil) & make the smil the current element. + // Command: createdomtree + + iDOMtreeRoot = CMDXMLSMILDocument::NewL(); + CMDXMLSMILsmil* smilElement = CMDXMLSMILsmil::NewL(iDOMtreeRoot); + + // The 'document' takes ownership of the 'smil' element + CMDXMLElement* documentElement = iDOMtreeRoot->DocumentElement(); + documentElement->AppendChild(smilElement); + iCurrentElement = smilElement; + } + else if (iCurrentCommand->Compare(KDeleteDOMtree) == 0) + { + // Delete the DOM tree + // Command: deletedomtree + + delete iDOMtreeRoot; // This will delete the entire DOM tree + iDOMtreeRoot = NULL; + iCurrentElement = NULL; + } + else if (iCurrentCommand->Compare(KCreate) == 0) + { + CMDXMLElement* newElement = NULL; + + // Determine element type to create + if ((*iArgumentList)[0].Compare(KA) == 0) + { + newElement = CMDXMLSMILa::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KAnchor) == 0) + { + newElement = CMDXMLSMILanchor::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KAnimation) == 0) + { + newElement = CMDXMLSMILanimation::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KArea) == 0) + { + newElement = CMDXMLSMILarea::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KAudio) == 0) + { + newElement = CMDXMLSMILaudio::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KBody) == 0) + { + newElement = CMDXMLSMILbody::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KHead) == 0) + { + newElement = CMDXMLSMILhead::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KImg) == 0) + { + newElement = CMDXMLSMILimg::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KLayout) == 0) + { + newElement = CMDXMLSMILlayout::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KMeta) == 0) + { + newElement = CMDXMLSMILmeta::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KPar) == 0) + { + newElement = CMDXMLSMILpar::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KRef) == 0) + { + newElement = CMDXMLSMILref::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KRegion) == 0) + { + newElement = CMDXMLSMILregion::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KRoot_layout) == 0) + { + newElement = CMDXMLSMILroot_layout::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KSeq) == 0) + { + newElement = CMDXMLSMILseq::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KSwitch) == 0) + { + newElement = CMDXMLSMILswitch::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KText) == 0) + { + newElement = CMDXMLSMILtext::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KTextstream) == 0) + { + newElement = CMDXMLSMILtextstream::NewL(iDOMtreeRoot); + } + else if ((*iArgumentList)[0].Compare(KVideo) == 0) + { + newElement = CMDXMLSMILvideo::NewL(iDOMtreeRoot); + } + else // Unrecognised element type + { + iWriter->WriteTest(KUnrecognisedElementType); + } + + + if ((*iArgumentList)[1].Compare(KAppend) == 0) + { + // Create an element of a specified type, and add it to the end of the current + // element’s child list. + // Command: create append + + TInt err = iCurrentElement->AppendChild(newElement); + if (err != KErrNone) + { + delete newElement; // Ownership was not taken + if (err == KErrNotSupported) + { + iWriter->WriteTest(KNotSupported); + } + else if (err == KErrXMLInvalidChild) + { + iWriter->WriteTest(KInvalidChild); + } + } + } + else if ((*iArgumentList)[1].Compare(KInsert) == 0) + { + // Create an element of a specified type, and insert it at a numerically defined + // position in the current element’s child list. + // Command: create insert n + // Use n = -3 for start of list (specified with NULL parameter), + // and no element to insert. + // Use n = -2 for start of list (specified with pointer to first child), + // and no element to insert. + // Use n = -1 for invalid pointer specifying place to insert. + // Use n = 0 for start of list (specified with NULL parameter) + // Use n = 1 for start of list (specified with pointer to first child) + // Then n = 2 for second child etc. + + // Convert the final argument to an integer + TLex lex = (*iArgumentList)[2]; + TInt position; + lex.Val(position); + + CMDXMLNode* insertBeforeChild = NULL; + + if (position == -3) + { + insertBeforeChild = NULL; // One way of specifying start of list + delete newElement; + newElement = NULL; + } + else if (position == -2) + { + insertBeforeChild = iCurrentElement->FirstChild(); + delete newElement; + newElement = NULL; + } + else if (position == -1) + { + insertBeforeChild = iCurrentElement; // Invalid pointer - not a child + } + else if (position == 0) + { + insertBeforeChild = NULL; // One way of specifying start of list + } + else if (position > 0) + { + insertBeforeChild = iCurrentElement->FirstChild(); + + while (position-- > 1 && insertBeforeChild != NULL) + { + insertBeforeChild = insertBeforeChild->NextSibling(); + } + + if (insertBeforeChild == NULL) + { + iWriter->WriteTest(KReachedEnd_ElementInsertedAtStart); + } + } + + TInt err = iCurrentElement->InsertBefore(insertBeforeChild, newElement); + if (err != KErrNone) + { + delete newElement; // Ownership was not taken + if (err == KErrNotSupported) + { + iWriter->WriteTest(KNotSupported); + } + else if (err == KErrXMLInvalidChild) + { + iWriter->WriteTest(KInvalidChild); + } + else if (err == KErrNotFound) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + } + } + else if ((*iArgumentList)[1].Compare(KReplace) == 0) + { + // Create an element of a specified type and use it to replace a numerically defined + // child element in the current element’s child list. Delete the old child. + // Command: create replace n + // Use n = -2 for start of list, and no element to insert. + // Use n = -1 for invalid pointer specifying child to replace. + // Use n = 0 for NULL, in place of pointer to child to replace. + // Use n = 1 for start of list + // Then n = 2 for second child etc. + + // Convert the final argument to an integer + TLex lex = (*iArgumentList)[2]; + TInt position; + lex.Val(position); + + CMDXMLNode* childToReplace = NULL; + + if (position == -2) + { + childToReplace = iCurrentElement->FirstChild(); + delete newElement; + newElement = NULL; + } + else if (position == -1) + { + childToReplace = iCurrentElement; // Invalid pointer - not a child + } + else if (position == 0) + { + childToReplace = NULL; // Invalid + } + else if (position > 0) + { + childToReplace = iCurrentElement->FirstChild(); + + while (position-- > 1 && childToReplace != NULL) + { + childToReplace = childToReplace->NextSibling(); + } + + if (childToReplace == NULL) + { + iWriter->WriteTest(KReachedEnd_NoChildReplaced); + } + } + + TInt err = iCurrentElement->ReplaceChild(newElement, childToReplace); + if (err != KErrNone) + { + delete newElement; // Ownership was not taken + if (err == KErrNotSupported) + { + iWriter->WriteTest(KNotSupported); + } + else if (err == KErrXMLInvalidChild) + { + iWriter->WriteTest(KInvalidChild); + } + else if (err == KErrNotFound) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + } + else // Replace operation was successful + { + delete childToReplace; + } + } + else // Unrecognised argument + { + iWriter->WriteTest(KUnrecognisedArgument); + } + } + else if (iCurrentCommand->Compare(KDeleteChild) == 0) + { + // Remove a child element, defined by a numeric position, in the current element’s + // list of children. Then delete it. + // Command: deletechild n + // Use n = -1 for invalid pointer specifying child to remove. + // Use n = 0 for NULL, in place of pointer to child to remove. + // Use n = 1 for start of list + // Then n = 2 for second child etc. + + // Convert the argument to an integer + TLex lex = (*iArgumentList)[0]; + TInt position; + lex.Val(position); + + CMDXMLNode* childToRemove = NULL; + + if (position == -1) + { + childToRemove = iCurrentElement; // Invalid pointer - not a child + } + else if (position == 0) + { + childToRemove = NULL; // Invalid + } + else if (position > 0) + { + childToRemove = iCurrentElement->FirstChild(); + + while (position-- > 1 && childToRemove != NULL) + { + childToRemove = childToRemove->NextSibling(); + } + + if (childToRemove == NULL) + { + iWriter->WriteTest(KReachedEnd_NoChildRemoved); + } + } + + TInt err = iCurrentElement->RemoveChild(childToRemove); + if (err != KErrNone) + { + if (err == KErrNotSupported) + { + iWriter->WriteTest(KNotSupported); + } + else if (err == KErrXMLInvalidChild) + { + iWriter->WriteTest(KInvalidChild); + } + else if (err == KErrNotFound) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + } + else // Remove operation was successful + { + delete childToRemove; + } + } + else if (iCurrentCommand->Compare(KParent) == 0) + { + // Navigate up the object tree to the current element’s parent. + // Command: parent + + CMDXMLNode* parentNode = iCurrentElement->ParentNode(); + + if (parentNode == NULL || parentNode->NodeName() == KXMLDocumentElementNodeName) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = (CMDXMLElement*)parentNode; + } + } + else if (iCurrentCommand->Compare(KRootSmil) == 0) + { + // Navigate to the element at the root of the DOM tree (smil). + // Command: rootsmil + + iCurrentElement = (CMDXMLElement*)iDOMtreeRoot->DocumentElement()->FirstChild(); + } + else if (iCurrentCommand->Compare(KFirstChild) == 0) + { + // Navigate to the first child of the current element. + // Command: firstchild + + CMDXMLNode* firstChild = iCurrentElement->FirstChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = (CMDXMLElement*)firstChild; + } + } + else if (iCurrentCommand->Compare(KLastChild) == 0) + { + // Navigate to the last child of the current element. + // Command: lastchild + + CMDXMLNode* lastChild = iCurrentElement->LastChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = (CMDXMLElement*)lastChild; + } + } + else if (iCurrentCommand->Compare(KNextSibling) == 0) + { + // Navigate to the next sibling of the current element. + // Command: nextsibling + + CMDXMLNode* nextSibling = iCurrentElement->NextSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = (CMDXMLElement*)nextSibling; + } + } + else if (iCurrentCommand->Compare(KPrevSibling) == 0) + { + // Navigate to the previous sibling of the current element. + // Command: prevsibling + + CMDXMLNode* prevSibling = iCurrentElement->PreviousSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = (CMDXMLElement*)prevSibling; + } + } + else if (iCurrentCommand->Compare(KFirst) == 0) + { + // Navigate to the first child, of specified element type, belonging to the current + // element. + // Command: first + + // If current element is a BasicElt, cast the pointer, so that we can call BasicElt + // members. + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() != KXMLSMILEltmeta) + { + CMDXMLSMILBasicElt* basicElt = (CMDXMLSMILBasicElt*)iCurrentElement; + + if ((*iArgumentList)[0].Compare(KAnimation) == 0) + { + CMDXMLElement* firstChild = basicElt->FirstanimationChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KAudio) == 0) + { + CMDXMLElement* firstChild = basicElt->FirstaudioChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KImg) == 0) + { + CMDXMLElement* firstChild = basicElt->FirstimgChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KPar) == 0) + { + CMDXMLElement* firstChild = basicElt->FirstparChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KRef) == 0) + { + CMDXMLElement* firstChild = basicElt->FirstrefChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KRegion) == 0) + { + CMDXMLElement* firstChild = basicElt->FirstregionChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KSeq) == 0) + { + CMDXMLElement* firstChild = basicElt->FirstseqChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KText) == 0) + { + CMDXMLElement* firstChild = basicElt->FirsttextChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KTextstream) == 0) + { + CMDXMLElement* firstChild = basicElt->FirsttextstreamChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else if ((*iArgumentList)[0].Compare(KVideo) == 0) + { + CMDXMLElement* firstChild = basicElt->FirstvideoChild(); + + if (firstChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = firstChild; + } + } + else // Invalid element type + { + iWriter->WriteTest(KInvalidArgument); + } + } + else // Error: Current element is not a BasicElt + { + iWriter->WriteTest(KNotABasicElt); + } + } + else if (iCurrentCommand->Compare(KLast) == 0) + { + // Navigate to the last child, of specified element type, belonging to the current + // element. + // Command: last + + // If current element is a BasicElt, cast the pointer, so that we can call BasicElt + // members. + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() != KXMLSMILEltmeta) + { + CMDXMLSMILBasicElt* basicElt = (CMDXMLSMILBasicElt*)iCurrentElement; + + if ((*iArgumentList)[0].Compare(KAnimation) == 0) + { + CMDXMLElement* lastChild = basicElt->LastanimationChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KAudio) == 0) + { + CMDXMLElement* lastChild = basicElt->LastaudioChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KImg) == 0) + { + CMDXMLElement* lastChild = basicElt->LastimgChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KPar) == 0) + { + CMDXMLElement* lastChild = basicElt->LastparChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KRef) == 0) + { + CMDXMLElement* lastChild = basicElt->LastrefChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KRegion) == 0) + { + CMDXMLElement* lastChild = basicElt->LastregionChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KSeq) == 0) + { + CMDXMLElement* lastChild = basicElt->LastseqChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KText) == 0) + { + CMDXMLElement* lastChild = basicElt->LasttextChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KTextstream) == 0) + { + CMDXMLElement* lastChild = basicElt->LasttextstreamChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else if ((*iArgumentList)[0].Compare(KVideo) == 0) + { + CMDXMLElement* lastChild = basicElt->LastvideoChild(); + + if (lastChild == NULL) + { + iWriter->WriteTest(KCannotFindSpecifiedChild); + } + else + { + iCurrentElement = lastChild; + } + } + else // Invalid element type + { + iWriter->WriteTest(KInvalidArgument); + } + } + else // Error: Current element is not a BasicElt + { + iWriter->WriteTest(KNotABasicElt); + } + } + else if (iCurrentCommand->Compare(KNext) == 0) + { + // Navigate to the next sibling, of specified element type, from a current + // element of the same type. + // Command: next + + if ((*iArgumentList)[0].Compare(KAnimation) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltanimation) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILanimation* eltOfSpecificType = (CMDXMLSMILanimation*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NextanimationSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KAudio) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltaudio) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILaudio* eltOfSpecificType = (CMDXMLSMILaudio*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NextaudioSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KImg) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltimg) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILimg* eltOfSpecificType = (CMDXMLSMILimg*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NextimgSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KPar) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltpar) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILpar* eltOfSpecificType = (CMDXMLSMILpar*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NextparSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KRef) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltref) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILref* eltOfSpecificType = (CMDXMLSMILref*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NextrefSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KRegion) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltregion) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILregion* eltOfSpecificType = (CMDXMLSMILregion*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NextregionSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KSeq) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltseq) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILseq* eltOfSpecificType = (CMDXMLSMILseq*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NextseqSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KText) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILElttext) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILtext* eltOfSpecificType = (CMDXMLSMILtext*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NexttextSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KTextstream) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILElttextstream) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILtextstream* eltOfSpecificType = (CMDXMLSMILtextstream*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NexttextstreamSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KVideo) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltvideo) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILvideo* eltOfSpecificType = (CMDXMLSMILvideo*)iCurrentElement; + + CMDXMLElement* nextSibling = eltOfSpecificType->NextvideoSibling(); + + if (nextSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = nextSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else // Invalid element type + { + iWriter->WriteTest(KInvalidArgument); + } + } + else if (iCurrentCommand->Compare(KPrev) == 0) + { + // Navigate to the previous sibling, of specified element type, from a current + // element of the same type. + // Command: prev + + if ((*iArgumentList)[0].Compare(KAnimation) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltanimation) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILanimation* eltOfSpecificType = (CMDXMLSMILanimation*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PreviousanimationSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KAudio) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltaudio) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILaudio* eltOfSpecificType = (CMDXMLSMILaudio*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PreviousaudioSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KImg) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltimg) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILimg* eltOfSpecificType = (CMDXMLSMILimg*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PreviousimgSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KPar) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltpar) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILpar* eltOfSpecificType = (CMDXMLSMILpar*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PreviousparSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KRef) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltref) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILref* eltOfSpecificType = (CMDXMLSMILref*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PreviousrefSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KRegion) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltregion) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILregion* eltOfSpecificType = (CMDXMLSMILregion*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PreviousregionSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KSeq) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltseq) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILseq* eltOfSpecificType = (CMDXMLSMILseq*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PreviousseqSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KText) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILElttext) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILtext* eltOfSpecificType = (CMDXMLSMILtext*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PrevioustextSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KTextstream) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILElttextstream) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILtextstream* eltOfSpecificType = (CMDXMLSMILtextstream*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PrevioustextstreamSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else if ((*iArgumentList)[0].Compare(KVideo) == 0) + { + // If current element is of the specified type... + if (iCurrentElement->NodeType() == CMDXMLNode::EElementNode + && iCurrentElement->NodeName() == KXMLSMILEltvideo) + { + // ...cast the pointer, so that we can call the members of that type. + CMDXMLSMILvideo* eltOfSpecificType = (CMDXMLSMILvideo*)iCurrentElement; + + CMDXMLElement* prevSibling = eltOfSpecificType->PreviousvideoSibling(); + + if (prevSibling == NULL) + { + iWriter->WriteTest(KAlreadyAtEndOfList); + } + else + { + iCurrentElement = prevSibling; + } + } + else // Error: Current element is not of the specified type + { + iWriter->WriteTest(KNotOfSpecifiedType); + } + } + else // Invalid element type + { + iWriter->WriteTest(KInvalidArgument); + } + } + else if (iCurrentCommand->Compare(KSetAtt) == 0) + { + // Set an attribute value of the current element (referring to the attribute by name). + // Command: setatt "" + + TInt err = iCurrentElement->SetAttributeL((*iArgumentList)[0], // aAttributeName + (*iArgumentList)[1]); // aAttributeValue + if (err != KErrNone) + { + if (err == KErrNotSupported) + { + iWriter->WriteTest(KInvalidArgument); + } + } + } + else if (iCurrentCommand->Compare(KGetAtt) == 0) + { + // Get an attribute value of the current element if it is set (referring to the attribute + // by name). + // Command: getatt + + TPtrC attributeValue; // Used to point to an existing HBufC, which could be any length. + // We don't want to copy it into a buffer. + + TInt err = iCurrentElement->GetAttribute((*iArgumentList)[0], // aAttributeName + attributeValue); + if (err != KErrNone) + { + if (err == KErrNotSupported) + { + iWriter->WriteTest(KInvalidArgument); + } + else if (err == KErrNotFound) + { + iWriter->WriteTest(KAttributeNotSet); + } + } + else // successful get + { + iWriter->WriteTest(attributeValue); + } + } + else if (iCurrentCommand->Compare(KUnsetAtt) == 0) + { + // Unset an attribute for the current element (referring to the attribute by name). + // Command: unsetatt + + TInt err = iCurrentElement->RemoveAttribute((*iArgumentList)[0]); // aAttributeName + + if (err != KErrNone) + { + if (err == KErrNotSupported) + { + iWriter->WriteTest(KInvalidArgument); + } + } + } + else if (iCurrentCommand->Compare(KLegalChildren) == 0) + { + // Check the child elements of the current element. + // Command: legalchildren + + if (iCurrentElement->CheckChildren()) + { + iWriter->WriteTest(KElementHasLegalChildren); + } + else + { + iWriter->WriteTest(KElementHasIllegalChildren); + } + } + else if (iCurrentCommand->Compare(KSetId) == 0) + { + IdAttTestL( KIdSetOp ); + } + else if (iCurrentCommand->Compare(KGetId) == 0) + { + IdAttTestL( KIdGetOp ); + } + else if (iCurrentCommand->Compare(KRemoveId) == 0) + { + IdAttTestL( KIdRemoveOp ); + } + else // Unrecognised command + { + iWriter->WriteTest(KUnrecognisedCommand); + } + + iArgumentList->Reset(); + delete iCurrentCommand; + iCurrentCommand = NULL; + } + +void CScriptRunner::IdAttTestL( TIdOp aOp ) + { + // We can set the Id by means of SetAttribute but we have a separate test that attempts + // to use the direct member functioin to test that. Id is only one of a range of attributes + // but it has been selected as a sample (because it is almost universal) + TInt err = KErrNone; + + switch (iCurrentElement->ElementType()) + { + case (KSMILElementa): + { + CMDXMLSMILa *ptr = CMDXMLSMILa::CastToSMILa(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementanchor): + { + CMDXMLSMILanchor *ptr = CMDXMLSMILanchor::CastToSMILanchor(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementanimation): + { + CMDXMLSMILanimation *ptr = CMDXMLSMILanimation::CastToSMILanimation(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementarea): + { + CMDXMLSMILarea *ptr = CMDXMLSMILarea::CastToSMILarea(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementaudio): + { + CMDXMLSMILaudio *ptr = CMDXMLSMILaudio::CastToSMILaudio(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementbody): + { + CMDXMLSMILbody *ptr = CMDXMLSMILbody::CastToSMILbody(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementhead): + { + CMDXMLSMILhead *ptr = CMDXMLSMILhead::CastToSMILhead(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementimg): + { + CMDXMLSMILimg *ptr = CMDXMLSMILimg::CastToSMILimg(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementlayout): + { + CMDXMLSMILlayout *ptr = CMDXMLSMILlayout::CastToSMILlayout(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementpar): + { + CMDXMLSMILpar *ptr = CMDXMLSMILpar::CastToSMILpar(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementref): + { + CMDXMLSMILref *ptr = CMDXMLSMILref::CastToSMILref(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementregion): + { + CMDXMLSMILregion *ptr = CMDXMLSMILregion::CastToSMILregion(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementroot_layout): + { + CMDXMLSMILroot_layout *ptr = CMDXMLSMILroot_layout::CastToSMILroot_layout(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementseq): + { + CMDXMLSMILseq *ptr = CMDXMLSMILseq::CastToSMILseq(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementsmil): + { + CMDXMLSMILsmil *ptr = CMDXMLSMILsmil::CastToSMILsmil(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementswitch): + { + CMDXMLSMILswitch *ptr = CMDXMLSMILswitch::CastToSMILswitch(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementtext): + { + CMDXMLSMILtext *ptr = CMDXMLSMILtext::CastToSMILtext(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementtextstream): + { + CMDXMLSMILtextstream *ptr = CMDXMLSMILtextstream::CastToSMILtextstream(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + case (KSMILElementvideo): + { + CMDXMLSMILvideo *ptr = CMDXMLSMILvideo::CastToSMILvideo(iCurrentElement); + switch(aOp) + { + case KIdSetOp: + err = ptr->SetAttIdL((*iArgumentList)[0]); + break; + case KIdGetOp: + if( ptr->IsAttIdSpecified() ) + { + TPtrC attributeValue = ptr->AttId(); + iWriter->WriteTest(attributeValue); + } + else + { + iWriter->WriteTest(KAttributeNotSet); + } + break; + case KIdRemoveOp: + ptr->RemoveAttId(); + break; + default: + err = KErrNotSupported; + break; + } + if (err != KErrNone) + { + iWriter->WriteTest(KInvalidArgument); + } + } + break; + + default: + iWriter->WriteTest(KUnrecognisedElementType); + break; + } //end switch + }