LPVOID TVTCreateXMLPacket4FinalizeSession(
TCHAR* sessionName,
int failureCount,
int summaryCount,
int numberOfTests,
int numberOfSuccessfulTests,
int numberOfUnsuccessfulTests)
{
TCHAR* result = null,
templatePath[MAX_PATH],
tempText[MAX_PATH]
;
if (!GetTemplateActionPath(templatePath)
) return result
;
// This open and parse the XML file:
XMLNode xRootNode = XMLNode::openFileHelper(templatePath,"easyTest");
XMLNode xAction = xRootNode.getChildNode("Action");
XMLAttribute* xAttribute = xAction.AddAttribute(stringDup("command",0),stringDup("updateObject", 0));
XMLNode xAttributes = xAction.getChildNode("Attributes");
xAttribute = xAttributes.AddAttribute(stringDup("object", 0),stringDup("session", 0));
xAttribute = xAttributes.AddAttribute(stringDup("session", 0),stringDup(sessionName, 0));
XMLNode xEntity = xAction.AddChild(stringDup("Entity"),0);
// Line 'Conclusion'
XMLNode xLine = TVTAddXMLLine(xEntity);
TVTAddXMLToken(xLine,"Conclusion: ");
TVTAddXMLToken(xLine,itoa(summaryCount,tempText,10));
TVTAddXMLToken(xLine," checks were made. There were ");
TVTAddXMLToken(xLine,itoa(failureCount,tempText,10));
TVTAddXMLToken(xLine," failures.");
// Line 'Statistics'
xLine = TVTAddXMLLine(xEntity);
TVTAddXMLToken(xLine,"Statistics:");
// Line # tests are executes.
xLine = TVTAddXMLLine(xEntity);
TVTAddXMLToken(xLine,itoa(numberOfTests,tempText,10));
if (numberOfTests == 1)
TVTAddXMLToken(xLine," test is executed.");
else
TVTAddXMLToken(xLine," tests are executed.")
;
xLine = TVTAddXMLLine(xEntity);
if (!numberOfUnsuccessfulTests)
{
TVTAddXMLToken(xLine,"No errors detected.");
}
else
{
TVTAddXMLToken(xLine,itoa(numberOfSuccessfulTests,tempText,10));
if (numberOfSuccessfulTests == 1)
TVTAddXMLToken(xLine," test is completed successfully. ");
else
TVTAddXMLToken(xLine," tests are completed successfully. ")
;
xLine = TVTAddXMLLine(xEntity);
TVTAddXMLToken(xLine,itoa(numberOfUnsuccessfulTests,tempText,10));
if (numberOfUnsuccessfulTests == 1)
TVTAddXMLToken(xLine," test failed.");
else
TVTAddXMLToken(xLine," tests failed.")
;
}
// Line
int size;
LPTSTR pText = xRootNode.createXMLString(1,&size);
result = new TCHAR [size+1];
if (result)
{
_tcscpy(result,pText);
}
free(pText);
return result;
}
/**
* Recursively parse an XML element.
*/
static bool
XML::ParseXMLElement(XMLNode &node, Parser *pXML)
{
bool is_declaration;
const TCHAR *text = nullptr;
XMLNode *pNew;
enum Status status; // inside or outside a tag
enum Attrib attrib = eAttribName;
/* the name of the attribute that is currently being */
tstring attribute_name;
assert(pXML);
// If this is the first call to the function
if (pXML->nFirst) {
// Assume we are outside of a tag definition
pXML->nFirst = false;
status = eOutsideTag;
} else {
// If this is not the first call then we should only be called when inside a tag.
status = eInsideTag;
}
// Iterate through the tokens in the document
while (true) {
// Obtain the next token
NextToken token = GetNextToken(pXML);
if (gcc_unlikely(token.type == eTokenError))
return false;
// Check the current status
switch (status) {
// If we are outside of a tag definition
case eOutsideTag:
// Check what type of token we obtained
switch (token.type) {
// If we have found text or quoted text
case eTokenText:
case eTokenQuotedText:
case eTokenEquals:
if (text == nullptr)
text = token.pStr;
break;
// If we found a start tag '<' and declarations '<?'
case eTokenTagStart:
case eTokenDeclaration:
// Cache whether this new element is a declaration or not
is_declaration = token.type == eTokenDeclaration;
// If we have node text then add this to the element
if (text != nullptr) {
size_t length = StripRight(text, token.pStr - text);
node.AddText(text, length);
text = nullptr;
}
// Find the name of the tag
token = GetNextToken(pXML);
// Return an error if we couldn't obtain the next token or
// it wasnt text
if (token.type != eTokenText) {
pXML->error = eXMLErrorMissingTagName;
return false;
}
// If the name of the new element differs from the name of
// the current element we need to add the new element to
// the current one and recurse
pNew = &node.AddChild(token.pStr, token.length,
is_declaration);
while (true) {
// Callself to process the new node. If we return
// FALSE this means we dont have any more
// processing to do...
if (!ParseXMLElement(*pNew, pXML)) {
return false;
} else {
// If the call to recurse this function
// evented in a end tag specified in XML then
// we need to unwind the calls to this
// function until we find the appropriate node
// (the element name and end tag name must
// match)
if (pXML->cbEndTag) {
// If we are back at the root node then we
// have an unmatched end tag
if (node.GetName() == nullptr) {
pXML->error = eXMLErrorUnmatchedEndTag;
return false;
}
// If the end tag matches the name of this
// element then we only need to unwind
// once more...
if (CompareTagName(node.GetName(), pXML->lpEndTag)) {
pXML->cbEndTag = 0;
}
return true;
} else {
// If we didn't have a new element to create
break;
}
}
}
break;
// If we found an end tag
case eTokenTagEnd:
// If we have node text then add this to the element
if (text != nullptr) {
size_t length = StripRight(text, token.pStr - text);
TCHAR *text2 = FromXMLString(text, length);
if (text2 == nullptr) {
pXML->error = eXMLErrorUnexpectedToken;
return false;
}
node.AddText(text2);
free(text2);
text = nullptr;
}
// Find the name of the end tag
token = GetNextToken(pXML);
// The end tag should be text
if (token.type != eTokenText) {
pXML->error = eXMLErrorMissingEndTagName;
return false;
}
// After the end tag we should find a closing tag
if (GetNextToken(pXML).type != eTokenCloseTag) {
pXML->error = eXMLErrorMissingEndTagName;
return false;
}
// We need to return to the previous caller. If the name
// of the tag cannot be found we need to keep returning to
// caller until we find a match
if (!CompareTagName(node.GetName(), token.pStr)) {
pXML->lpEndTag = token.pStr;
pXML->cbEndTag = token.length;
}
// Return to the caller
return true;
// Errors...
case eTokenCloseTag: /* '>' */
case eTokenShortHandClose: /* '/>' */
pXML->error = eXMLErrorUnexpectedToken;
return false;
default:
break;
}
break;
// If we are inside a tag definition we need to search for attributes
case eInsideTag:
// Check what part of the attribute (name, equals, value) we
// are looking for.
switch (attrib) {
// If we are looking for a new attribute
case eAttribName:
// Check what the current token type is
switch (token.type) {
// If the current type is text...
// Eg. 'attribute'
case eTokenText:
// Cache the token then indicate that we are next to
// look for the equals
attribute_name.assign(token.pStr, token.length);
attrib = eAttribEquals;
break;
// If we found a closing tag...
// Eg. '>'
case eTokenCloseTag:
// We are now outside the tag
status = eOutsideTag;
break;
// If we found a short hand '/>' closing tag then we can
// return to the caller
case eTokenShortHandClose:
return true;
// Errors...
case eTokenQuotedText: /* '"SomeText"' */
case eTokenTagStart: /* '<' */
case eTokenTagEnd: /* '</' */
case eTokenEquals: /* '=' */
case eTokenDeclaration: /* '<?' */
pXML->error = eXMLErrorUnexpectedToken;
return false;
default:
break;
}
break;
// If we are looking for an equals
case eAttribEquals:
// Check what the current token type is
switch (token.type) {
// If the current type is text...
// Eg. 'Attribute AnotherAttribute'
case eTokenText:
// Add the unvalued attribute to the list
node.AddAttribute(std::move(attribute_name), _T(""), 0);
// Cache the token then indicate. We are next to
// look for the equals attribute
attribute_name.assign(token.pStr, token.length);
break;
// If we found a closing tag 'Attribute >' or a short hand
// closing tag 'Attribute />'
case eTokenShortHandClose:
case eTokenCloseTag:
assert(!attribute_name.empty());
// If we are a declaration element '<?' then we need
// to remove extra closing '?' if it exists
if (node.IsDeclaration() && attribute_name.back() == _T('?')) {
attribute_name.pop_back();
}
if (!attribute_name.empty())
// Add the unvalued attribute to the list
node.AddAttribute(std::move(attribute_name), _T(""), 0);
// If this is the end of the tag then return to the caller
if (token.type == eTokenShortHandClose)
return true;
// We are now outside the tag
status = eOutsideTag;
break;
// If we found the equals token...
// Eg. 'Attribute ='
case eTokenEquals:
// Indicate that we next need to search for the value
// for the attribute
attrib = eAttribValue;
break;
// Errors...
case eTokenQuotedText: /* 'Attribute "InvalidAttr"'*/
case eTokenTagStart: /* 'Attribute <' */
case eTokenTagEnd: /* 'Attribute </' */
case eTokenDeclaration: /* 'Attribute <?' */
pXML->error = eXMLErrorUnexpectedToken;
return false;
default:
break;
}
break;
// If we are looking for an attribute value
case eAttribValue:
// Check what the current token type is
switch (token.type) {
// If the current type is text or quoted text...
// Eg. 'Attribute = "Value"' or 'Attribute = Value' or
// 'Attribute = 'Value''.
case eTokenText:
case eTokenQuotedText:
// If we are a declaration element '<?' then we need
// to remove extra closing '?' if it exists
if (node.IsDeclaration() && (token.pStr[token.length - 1]) == _T('?')) {
token.length--;
}
// Add the valued attribute to the list
if (token.type == eTokenQuotedText) {
token.pStr++;
token.length -= 2;
}
assert(!attribute_name.empty());
{
TCHAR *value = FromXMLString(token.pStr, token.length);
if (value == nullptr) {
pXML->error = eXMLErrorUnexpectedToken;
return false;
}
node.AddAttribute(std::move(attribute_name),
value, _tcslen(value));
free(value);
}
// Indicate we are searching for a new attribute
attrib = eAttribName;
break;
// Errors...
case eTokenTagStart: /* 'Attr = <' */
case eTokenTagEnd: /* 'Attr = </' */
case eTokenCloseTag: /* 'Attr = >' */
case eTokenShortHandClose: /* "Attr = />" */
case eTokenEquals: /* 'Attr = =' */
case eTokenDeclaration: /* 'Attr = <?' */
pXML->error = eXMLErrorUnexpectedToken;
return false;
default:
break;
}
}
}
}
}