dmitryh 2004/11/08 10:05:41
Modified: c/src/xalanc/Harness XalanFileUtility.cpp
XalanFileUtility.hpp XalanXMLFileReporter.cpp
XalanXMLFileReporter.hpp
Log:
Initial implementation on the pluggable memory management
Revision Changes Path
1.2 +257 -159 xml-xalan/c/src/xalanc/Harness/XalanFileUtility.cpp
Index: XalanFileUtility.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/xalanc/Harness/XalanFileUtility.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XalanFileUtility.cpp 3 Aug 2004 15:59:09 -0000 1.1
+++ XalanFileUtility.cpp 8 Nov 2004 18:05:41 -0000 1.2
@@ -21,7 +21,6 @@
#include <cstdlib>
#include <cstdio>
#include <ctime>
-#include <vector>
#include <climits>
#include <cstring>
@@ -122,20 +121,20 @@
XALAN_USING_STD(endl)
-const XalanDOMString XalanFileUtility::s_emptyString;
+const XalanDOMString
XalanFileUtility::s_emptyString(XalanMemMgrs::getDummyMemMgr());
-XalanFileUtility::reportStruct::reportStruct() :
- theDrive(),
- testOrFile(),
- xmlFileURL(),
- xslFileURL(),
- xmlFormat(),
+XalanFileUtility::reportStruct::reportStruct(MemoryManagerType& theManager) :
+ theDrive(theManager),
+ testOrFile(theManager),
+ xmlFileURL(theManager),
+ xslFileURL(theManager),
+ xmlFormat(theManager),
msg(0),
- currentNode(),
- actual(),
- expected(),
+ currentNode(theManager),
+ actual(theManager),
+ expected(theManager),
pass(0),
fail(0),
nogold(0)
@@ -156,12 +155,12 @@
-XalanFileUtility::cmdParams::cmdParams() :
+XalanFileUtility::cmdParams::cmdParams(MemoryManagerType& theManager) :
help(),
- base(),
- output(),
- gold(),
- sub(),
+ base(theManager),
+ output(theManager),
+ gold(theManager),
+ sub(theManager),
source(0),
skip(false),
iters(0)
@@ -188,9 +187,9 @@
-XalanFileUtility::XalanFileUtility() :
- data(),
- args()
+XalanFileUtility::XalanFileUtility(MemoryManagerType& theManager) :
+ data(theManager),
+ args(theManager)
{
cout << endl
<< "Using Xalan version "
@@ -211,14 +210,16 @@
#if !defined(WIN32)
-XalanDOMString
-XalanFileUtility::getDrive()
+XalanDOMString&
+XalanFileUtility::getDrive(XalanDOMString& theResult)
{
- return XalanDOMString();
+ theResult.erase();
+
+ return theResult;
}
#else
-XalanDOMString
-XalanFileUtility::getDrive()
+XalanDOMString&
+XalanFileUtility::getDrive(XalanDOMString& theResult)
{
const char temp[] =
{
@@ -226,8 +227,9 @@
':',
'\0'
};
-
- return XalanDOMString(temp, sizeof(temp) - 1);
+ theResult.assign(temp, sizeof(temp) - 1);
+
+ return theResult;
}
#endif
@@ -254,9 +256,9 @@
}
else
{
- if (checkDir(XalanDOMString(argv[1])))
+ if
(checkDir(XalanDOMString(argv[1],XalanMemMgrs::getDefaultXercesMemMgr())))
{
- assign(args.base, XalanDOMString(argv[1]));
+ assign(args.base,
XalanDOMString(argv[1],XalanMemMgrs::getDefaultXercesMemMgr()));
}
else
{
@@ -275,7 +277,7 @@
++i;
if(i < argc && argv[i][0] != '-')
{
- assign(args.output, XalanDOMString(argv[i]));
+ assign(args.output,
XalanDOMString(argv[i],XalanMemMgrs::getDefaultXercesMemMgr()));
append(args.output, s_pathSep);
checkAndCreateDir(args.output);
fsetOut = false;
@@ -291,11 +293,14 @@
++i;
if(i < argc && argv[i][0] != '-')
{
- assign(args.gold, XalanDOMString(argv[i]));
+ assign(args.gold,
XalanDOMString(argv[i],XalanMemMgrs::getDefaultXercesMemMgr()));
if ( !checkDir(args.gold) )
{
- cout << "Given Gold dir - " <<
c_str(TranscodeToLocalCodePage(args.gold)) << " - does not exist" << endl;
+ CharVectorType
theResult(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(args.gold, theResult, true);
+
+ cout << "Given Gold dir - " << c_str(theResult) << " -
does not exist" << endl;
fSuccess = false;
}
@@ -340,7 +345,7 @@
++i;
if(i < argc && argv[i][0] != '-')
{
- assign(args.sub, XalanDOMString(argv[i]));
+ assign(args.sub,
XalanDOMString(argv[i],XalanMemMgrs::getDefaultXercesMemMgr()));
}
else
{
@@ -386,7 +391,7 @@
args.output.assign(args.base, 0, ii + 1);
}
- append(args.output,XalanDOMString(outDir));
+
append(args.output,XalanDOMString(outDir,XalanMemMgrs::getDefaultXercesMemMgr()));
checkAndCreateDir(args.output);
append(args.output,s_pathSep);
@@ -396,10 +401,12 @@
if (fsetGold)
{
args.gold = args.base;
- append(args.gold,XalanDOMString("-gold"));
+
append(args.gold,XalanDOMString("-gold",XalanMemMgrs::getDefaultXercesMemMgr()));
if ( !checkDir(args.gold) )
{
- cout << "Assumed Gold dir - " <<
c_str(TranscodeToLocalCodePage(args.gold)) << " - does not exist" << endl;
+ CharVectorType
theResult(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(args.gold, theResult, true);
+ cout << "Assumed Gold dir - " << c_str(theResult) << " - does
not exist" << endl;
fSuccess = false;
}
append(args.gold,s_pathSep);
@@ -422,32 +429,40 @@
// Notes: It builds the searchSpecification by concatenating all the
// necessary components.
//
-XalanFileUtility::FileNameVectorType
+XalanFileUtility::FileNameVectorType&
XalanFileUtility::getTestFileNames(
const XalanDOMString& baseDir,
const XalanDOMString& relDir,
- bool useDirPrefix)
+ bool useDirPrefix,
+ FileNameVectorType& theFiles)
{
char buffer3[PATH_MAX];
getcwd(buffer3, PATH_MAX);
- const XalanDOMString searchSuffix(XALAN_STATIC_UCODE_STRING("*.xsl"));
- XalanDOMString searchSpecification;
+ const XalanDOMString
searchSuffix(XALAN_STATIC_UCODE_STRING("*.xsl"),XalanMemMgrs::getDefaultXercesMemMgr());
+ XalanDOMString
searchSpecification(XalanMemMgrs::getDefaultXercesMemMgr());
// Allow directory search w/o mandating files start with directory name.
Required for files
// garnered from XSLTMARK performance directory exm.
if (useDirPrefix)
{
- assign(searchSpecification, baseDir + relDir + s_pathSep + relDir +
searchSuffix);
+ searchSpecification.assign(baseDir);
+ searchSpecification += relDir;
+ searchSpecification += s_pathSep;
+ searchSpecification += relDir;
+ searchSpecification += searchSuffix;
}
else
{
- assign(searchSpecification, baseDir + relDir + s_pathSep +
searchSuffix);
+ searchSpecification.assign(baseDir);
+ searchSpecification += relDir;
+ searchSpecification += s_pathSep;
+ searchSpecification += searchSuffix;
}
DirectoryEnumeratorFunctor<FileNameVectorType, XalanDOMString>
theEnumerator;
- FileNameVectorType theFiles;
+
theEnumerator(searchSpecification, theFiles);
chdir(buffer3);
@@ -460,17 +475,20 @@
//
// Notes: The searchSpecification in this case is just "*".
//
*/
-XalanFileUtility::FileNameVectorType
-XalanFileUtility::getDirectoryNames(const XalanDOMString&
rootDirectory)
+XalanFileUtility::FileNameVectorType&
+XalanFileUtility::getDirectoryNames(const XalanDOMString&
rootDirectory,
+ XalanFileUtility::FileNameVectorType& theFiles)
{
char buffer2[PATH_MAX];
getcwd(buffer2, PATH_MAX);
- const XalanDOMString dirSpec(XALAN_STATIC_UCODE_STRING("*"));
+ const XalanDOMString
dirSpec(XALAN_STATIC_UCODE_STRING("*"),XalanMemMgrs::getDefaultXercesMemMgr());
DirectoryEnumeratorFunctor<FileNameVectorType, XalanDOMString,
DirectoryFilterPredicate> theEnumerator;
- FileNameVectorType theFiles;
- theEnumerator(XalanDOMString(rootDirectory), XalanDOMString(dirSpec),
theFiles);
+
+ theEnumerator(XalanDOMString(rootDirectory,
XalanMemMgrs::getDefaultXercesMemMgr()),
+ XalanDOMString(dirSpec,
XalanMemMgrs::getDefaultXercesMemMgr()),
+ theFiles);
chdir(buffer2);
@@ -486,7 +504,10 @@
bool fResult = false;
- if ( !chdir(c_str(TranscodeToLocalCodePage(directory))) )
+ CharVectorType theResult(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(directory, theResult, true);
+
+ if ( !chdir(c_str(theResult)) )
{
fResult = true;
}
@@ -503,13 +524,18 @@
getcwd(buffer, PATH_MAX);
- if ( (chdir(c_str(TranscodeToLocalCodePage(directory)))) )
+ CharVectorType theResult(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(directory, theResult, true);
+
+ if ( (chdir(c_str(theResult))))
{
//cout << "Couldn't change to " << directory << ", will create it."
<< endl;
+ CharVectorType
theResult1(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(directory, theResult1, true);
#if defined(WIN32)
- if ( !mkdir(c_str(TranscodeToLocalCodePage(directory))))
+ if ( !mkdir(c_str(theResult)))
#else
- if ( !mkdir(c_str(TranscodeToLocalCodePage(directory)),
DIR_MODE_BITS))
+ if ( !mkdir(c_str(theResult), DIR_MODE_BITS))
#endif
{
cout << directory << " created." << endl;
@@ -530,13 +556,13 @@
// Notes:
*/
-XalanDOMString
+XalanDOMString&
XalanFileUtility::generateFileName(
const XalanDOMString& theXMLFileName,
const char* suffix,
+ XalanDOMString& targetFile,
bool* status)
{
- XalanDOMString targetFile;
int thePeriodIndex = -1;
const int theLength = length(theXMLFileName);
@@ -553,13 +579,16 @@
{
targetFile.assign(theXMLFileName, 0, thePeriodIndex + 1);
- targetFile += XalanDOMString(suffix);
+ targetFile += XalanDOMString(suffix,
XalanMemMgrs::getDefaultXercesMemMgr());
}
// Check the .xml file exists.
if (!strcmp(suffix,"xml"))
{
- FILE* fileHandle =
fopen(c_str(TranscodeToLocalCodePage(targetFile)), "r");
+ CharVectorType theResult(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(targetFile, theResult, true);
+
+ FILE* fileHandle = fopen(c_str(theResult), "r");
if (fileHandle == 0)
{
cout << "TEST ERROR: File Missing: " << targetFile << endl;
@@ -586,8 +615,8 @@
// 03151046 is "Mar 15 10:46"
*/
-XalanDOMString
-XalanFileUtility::generateUniqRunid()
+XalanDOMString&
+XalanFileUtility::generateUniqRunid(XalanDOMString& theResult)
{
#if defined(XALAN_STRICT_ANSI_HEADERS)
using std::tm;
@@ -605,7 +634,9 @@
strftime( tmpbuf, 10,"%m%d%H%M",newtime );
- return XalanDOMString(tmpbuf);
+ theResult.assign(tmpbuf);
+
+ return theResult;
}
@@ -614,11 +645,12 @@
// Inputs: None
//
-XalanDOMString
-XalanFileUtility::getXercesVersion()
+XalanDOMString&
+XalanFileUtility::getXercesVersion(XalanDOMString& theResult)
{
+ theResult.assign(gXercesFullVersionStr);
- return XalanDOMString(gXercesFullVersionStr);
+ return theResult;
}
/* This routine creates a FormatterToXML FormatterListener. This is used to
format
@@ -635,25 +667,28 @@
const XalanDOMString& mimeEncoding,
const StylesheetRoot* stylesheet)
{
- XalanDOMString version;
+ XalanDOMString version(resultWriter.getMemoryManager());
bool outputIndent= 0;
- XalanDOMString mediatype;
- XalanDOMString doctypeSystem;
- XalanDOMString doctypePublic;
- XalanDOMString standalone;
+ XalanDOMString mediatype(resultWriter.getMemoryManager());
+ XalanDOMString doctypeSystem(resultWriter.getMemoryManager());
+ XalanDOMString doctypePublic(resultWriter.getMemoryManager());
+ XalanDOMString standalone(resultWriter.getMemoryManager());
if (stylesheet != 0)
{
- version = stylesheet->getOutputVersion();
+ XalanDOMString theBuffer(resultWriter.getMemoryManager());
- mediatype = stylesheet->getOutputMediaType();
- doctypeSystem = stylesheet->getOutputDoctypeSystem();
- doctypePublic = stylesheet->getOutputDoctypePublic();
- standalone = stylesheet->getOutputStandalone();
+ version = stylesheet->getOutputVersion(theBuffer);
+
+ mediatype = stylesheet->getOutputMediaType(theBuffer);
+ doctypeSystem = stylesheet->getOutputDoctypeSystem(theBuffer);
+ doctypePublic = stylesheet->getOutputDoctypePublic(theBuffer);
+ standalone = stylesheet->getOutputStandalone(theBuffer);
outputIndent = stylesheet->getOutputIndent();
}
- return new FormatterToXML(
+ return FormatterToXML::create(
+ resultWriter.getMemoryManager(),
resultWriter,
version,
outputIndent,
@@ -699,20 +734,20 @@
// if the compairson fails gather up the failure data and determine
if it failed
// due to bad output or missing Gold file. Lastly, log the failure.
- Hashtable attrs;
- Hashtable actexp;
+ Hashtable attrs(logfile.getMemoryManager());
+ Hashtable actexp(logfile.getMemoryManager());
reportError();
- attrs.insert(Hashtable::value_type(XalanDOMString("reason"),
XalanDOMString(data.msg)));
- attrs.insert(Hashtable::value_type(XalanDOMString("atNode"),
data.currentNode));
- actexp.insert(Hashtable::value_type(XalanDOMString("exp"),
data.expected));
- actexp.insert(Hashtable::value_type(XalanDOMString("act"),
data.actual));
-
- actexp.insert(Hashtable::value_type(XalanDOMString("xsl"),
data.xslFileURL));
- actexp.insert(Hashtable::value_type(XalanDOMString("xml"),
data.xmlFileURL));
- actexp.insert(Hashtable::value_type(XalanDOMString("result"),
outputFile));
- actexp.insert(Hashtable::value_type(XalanDOMString("gold"),
goldFile));
+ attrs.insert(XalanDOMString("reason", logfile.getMemoryManager()),
XalanDOMString(data.msg, logfile.getMemoryManager()));
+ attrs.insert(XalanDOMString("atNode", logfile.getMemoryManager()),
data.currentNode);
+ actexp.insert(XalanDOMString("exp",
logfile.getMemoryManager()),data.expected);
+ actexp.insert(XalanDOMString("act", logfile.getMemoryManager()),
data.actual);
+
+ actexp.insert(XalanDOMString("xsl", logfile.getMemoryManager()),
data.xslFileURL);
+ actexp.insert( XalanDOMString("xml", logfile.getMemoryManager()),
data.xmlFileURL);
+ actexp.insert( XalanDOMString("result", logfile.getMemoryManager()),
outputFile );
+ actexp.insert( XalanDOMString("gold", logfile.getMemoryManager()),
goldFile);
if (ambgFlag < data.nogold)
{
@@ -722,6 +757,7 @@
{
logfile.logCheckFail(data.testOrFile, attrs, actexp);
}
+
}
}
@@ -735,6 +771,8 @@
const XalanDOMString& goldFile,
bool containsOnly)
{
+ MemoryManagerType& mgr = logfile.getMemoryManager();
+
if(actual == expected ||
(containsOnly == true && indexOf(actual, expected) !=
XalanDOMString::npos))
{
@@ -753,17 +791,18 @@
typedef XalanXMLFileReporter::Hashtable Hashtable;
- Hashtable actexp;
+ Hashtable actexp(mgr);
- actexp.insert(Hashtable::value_type(XalanDOMString("exp"),
expected));
- actexp.insert(Hashtable::value_type(XalanDOMString("act"), actual));
- actexp.insert(Hashtable::value_type(XalanDOMString("xsl"),
data.xslFileURL));
- actexp.insert(Hashtable::value_type(XalanDOMString("xml"),
data.xmlFileURL));
- actexp.insert(Hashtable::value_type(XalanDOMString("result"),
outputFile));
- actexp.insert(Hashtable::value_type(XalanDOMString("gold"),
goldFile));
+ actexp.insert( XalanDOMString("exp", mgr), expected);
+ actexp.insert( XalanDOMString("act", mgr), actual);
+ actexp.insert( XalanDOMString("xsl", mgr), data.xslFileURL);
+ actexp.insert( XalanDOMString("xml", mgr), data.xmlFileURL);
+ actexp.insert( XalanDOMString("result", mgr), outputFile);
+ actexp.insert( XalanDOMString("gold", mgr), goldFile);
// Todo: Need to determine if I should check for missing gold in
these cases.
logfile.logCheckFail(data.testOrFile, actexp);
+
}
}
@@ -788,11 +827,13 @@
const XSLTInputSource& goldInputSource,
XalanXMLFileReporter& logfile)
{
+ MemoryManagerType& theManager = logfile.getMemoryManager();
+
const int ambgFlag = data.nogold;
- const XalanDOMString mimeEncoding("");
+ const XalanDOMString mimeEncoding("", theManager);
- XalanFileOutputStream myOutput(theOutputFile);
+ XalanFileOutputStream myOutput(theOutputFile, theManager);
XalanOutputStreamPrintWriter myResultWriter(myOutput);
FormatterListener* const theFormatter =
@@ -802,14 +843,14 @@
mimeEncoding,
compiledSS->getStylesheetRoot());
- FormatterTreeWalker theTreeWalker(*theFormatter);
+ FormatterTreeWalker theTreeWalker(*theFormatter, theManager);
theTreeWalker.traverse(dom);
- delete theFormatter;
+ destroyObjWithMemMgr( theFormatter, theManager);
XalanSourceTreeDOMSupport domSupport;
- XalanSourceTreeParserLiaison parserLiaison(domSupport);
+ XalanSourceTreeParserLiaison parserLiaison(theManager, domSupport);
domSupport.setParserLiaison(&parserLiaison);
@@ -828,15 +869,15 @@
// if the compairson fails gather up the failure data and determine
if it failed
// due to bad output or missing Gold file. Lastly, log the failure.
- Hashtable attrs;
- Hashtable actexp;
+ Hashtable attrs(theManager);
+ Hashtable actexp(theManager);
reportError();
- attrs.insert(Hashtable::value_type(XalanDOMString("reason"),
XalanDOMString(data.msg)));
- attrs.insert(Hashtable::value_type(XalanDOMString("atNode"),
data.currentNode));
- actexp.insert(Hashtable::value_type(XalanDOMString("exp"),
data.expected));
- actexp.insert(Hashtable::value_type(XalanDOMString("act"),
data.actual));
+ attrs.insert( XalanDOMString("reason", theManager),
XalanDOMString(data.msg, theManager));
+ attrs.insert( XalanDOMString("atNode", theManager), data.currentNode
);
+ actexp.insert( XalanDOMString("exp", theManager), data.expected);
+ actexp.insert( XalanDOMString("act", theManager), data.actual);
if (ambgFlag < data.nogold)
{
@@ -846,6 +887,7 @@
{
logfile.logCheckFail(data.testOrFile, attrs, actexp);
}
+
}
}
@@ -870,8 +912,10 @@
const XSLTInputSource resultInputSource(outputFile);
const XSLTInputSource goldInputSource(goldFile);
+ MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr();
+
XalanSourceTreeDOMSupport domSupport;
- XalanSourceTreeParserLiaison parserLiaison(domSupport);
+ XalanSourceTreeParserLiaison parserLiaison(theManager, domSupport );
domSupport.setParserLiaison(&parserLiaison);
@@ -894,7 +938,12 @@
{
cout << "SAXException: Using fileCompare to check output.\n";
- return fileCompare(c_str(TranscodeToLocalCodePage(goldFile)),
c_str(TranscodeToLocalCodePage(outputFile)));
+ CharVectorType
goldFileVec(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(goldFile, goldFileVec, true);
+
+ CharVectorType
outputFileVec(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(outputFile, outputFileVec, true);
+ return fileCompare(c_str(goldFileVec), c_str(outputFileVec));
}
}
@@ -942,10 +991,12 @@
char temp[10]; // buffer to hold line number
char lineNum = 1;
+ MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr();
+
// Set fail data incase there are i/o problems with the files to compare.
- data.expected = XalanDOMString(" ");
- data.actual = XalanDOMString(" ");
- data.currentNode = XalanDOMString("Line: 0");
+ data.expected = XalanDOMString(" ", theManager);
+ data.actual = XalanDOMString(" ", theManager);
+ data.currentNode = XalanDOMString("Line: 0", theManager);
// Attempt to open the files.
FILE* const result = fopen(outputFile, "r");
@@ -977,7 +1028,8 @@
if (ferror(gold) || ferror(result))
{
data.msg = "Read Error - Gold/Result file";
- data.currentNode = XalanDOMString("Line: ") +
XalanDOMString(temp);
+ data.currentNode = XalanDOMString("Line: ", theManager);
+ data.currentNode += XalanDOMString(temp, theManager);
return false;
}
@@ -999,9 +1051,16 @@
replaceNonAsciiCharacters(rline, '?');
data.msg = "Text based comparison failure";
- data.expected = XalanDOMString("<![CDATA[") +
XalanDOMString(gline) + XalanDOMString("]]>");
- data.actual = XalanDOMString("<![CDATA[") +
XalanDOMString(rline) + XalanDOMString("]]>");
- data.currentNode = XalanDOMString("Line: ") +
XalanDOMString(temp);
+ data.expected = XalanDOMString("<![CDATA[", theManager);
+ data.expected += XalanDOMString(gline, theManager);
+ data.expected += XalanDOMString("]]>", theManager);
+
+ data.actual = XalanDOMString("<![CDATA[", theManager);
+ data.actual += XalanDOMString(rline, theManager);
+ data.actual += XalanDOMString("]]>", theManager);
+
+ data.currentNode = XalanDOMString("Line: ", theManager);
+ data.currentNode += XalanDOMString(temp, theManager);
data.fail += 1;
fclose(result); fclose(gold);
return false;
@@ -1036,12 +1095,14 @@
const XalanDOMString& docNodeName = doc.getNodeName();
+ MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr();
+
if (goldNodeType != docNodeType)
{
collectData("NodeType mismatch.",
docNodeName,
- XalanDOMString(xalanNodeTypes[docNodeType]),
- XalanDOMString(xalanNodeTypes[goldNodeType]));
+ XalanDOMString(xalanNodeTypes[docNodeType], theManager),
+ XalanDOMString(xalanNodeTypes[goldNodeType],
theManager));
return false;
}
@@ -1281,12 +1342,14 @@
const XalanDOMString& docNodeName = doc.getNodeName();
+ MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr();
+
if (goldNodeType != docNodeType)
{
collectData("NodeType mismatch.",
docNodeName,
- XalanDOMString(xalanNodeTypes[docNodeType]),
- XalanDOMString(xalanNodeTypes[goldNodeType]));
+ XalanDOMString(xalanNodeTypes[docNodeType], theManager),
+ XalanDOMString(xalanNodeTypes[goldNodeType],
theManager));
return false;
}
@@ -1479,6 +1542,8 @@
const unsigned int numGoldAttr = goldAttrs->getLength();
const unsigned int numDomAttr = docAttrs ->getLength();
+ MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr();
+
/*
// This needs to be uncommented if 'compare.exe' is to work.
// If this is the 'root' element strip off the xmlns:xml namespace
attribute,
@@ -1513,7 +1578,7 @@
collectData("Element missing named Attribute. ",
docNodeName,
goldAttrName,
- XalanDOMString("NOTHING"));
+ XalanDOMString("NOTHING", theManager));
return false;
}
@@ -1526,8 +1591,8 @@
sprintf(buf2, "%u", numDomAttr);
collectData("Wrong number of attributes. ",
docNodeName,
- XalanDOMString(buf1),
- XalanDOMString(buf2));
+ XalanDOMString(buf1, theManager),
+ XalanDOMString(buf2, theManager));
return false;
}
@@ -1545,8 +1610,8 @@
{
collectData("Element missing ChildNode. ",
docNodeName,
- XalanDOMString(goldNextNode->getNodeName()),
- XalanDOMString("NOTHING"));
+ XalanDOMString(goldNextNode->getNodeName(),
theManager),
+ XalanDOMString("NOTHING", theManager));
return false;
}
}
@@ -1558,17 +1623,17 @@
{
collectData("Result has additional Child node: ",
docNodeName,
- XalanDOMString("NOTHING"),
- XalanDOMString(domNextNode->getNodeName()) +
XalanDOMString(" \"") +
- XalanDOMString(domNextNode->getNodeValue()) +
XalanDOMString("\""));
+ XalanDOMString("NOTHING", theManager),
+ XalanDOMString(domNextNode->getNodeName(),
theManager).append(XalanDOMString(" \"", theManager).append(
+ XalanDOMString(domNextNode->getNodeValue(),
theManager).append(XalanDOMString("\"", theManager)))));
}
// Additional node is NOT text, so just print it's Name.
else
{
collectData("Result has additional Child node: ",
docNodeName,
- XalanDOMString("NOTHING"),
- XalanDOMString(domNextNode->getNodeName()));
+ XalanDOMString("NOTHING", theManager),
+ XalanDOMString(domNextNode->getNodeName(),
theManager));
}
return false;
@@ -1593,6 +1658,8 @@
const XalanDOMString& docNsUri = doc.getNamespaceURI();
const XalanDOMString& goldNsUri = gold.getNamespaceURI();
+ MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr();
+
//debugNodeData(docNodeName);
// This essentially checks 2 things, that the prefix and localname are
the
@@ -1649,7 +1716,7 @@
collectData("Element missing named Attribute. ",
docNodeName,
goldAttrName,
- XalanDOMString("NOTHING"));
+ XalanDOMString("NOTHING", theManager));
return false;
}
@@ -1662,8 +1729,8 @@
sprintf(buf2, "%u", numDomAttr);
collectData("Wrong number of attributes. ",
docNodeName,
- XalanDOMString(buf1),
- XalanDOMString(buf2));
+ XalanDOMString(buf1, theManager),
+ XalanDOMString(buf2, theManager));
return false;
}
@@ -1755,7 +1822,11 @@
void
XalanFileUtility::debugNodeData(const XalanDOMString& value) const
{
- cout << "Node is: " << c_str(TranscodeToLocalCodePage(value)) << endl;
+
+ CharVectorType valueVec(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(value, valueVec, true);
+
+ cout << "Node is: " << c_str(valueVec) << endl;
}
@@ -1765,8 +1836,15 @@
const XalanDOMString& node,
const XalanDOMString& value) const
{
- cout << "Node is: " << c_str(TranscodeToLocalCodePage(node)) << " "
- << "Value is: \"" << c_str(TranscodeToLocalCodePage(value)) <<
"\"\n";
+
+ CharVectorType valueVec(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(value, valueVec, true);
+
+ CharVectorType nodeVec(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(node, nodeVec, true);
+
+ cout << "Node is: " << c_str(nodeVec) << " "
+ << "Value is: \"" << c_str(valueVec) << "\"\n";
}
@@ -1774,7 +1852,11 @@
void
XalanFileUtility::debugAttributeData(const XalanDOMString& value) const
{
- cout << "Attribute is: " << c_str(TranscodeToLocalCodePage(value)) <<
endl;
+ CharVectorType
theTargetVector(XalanMemMgrs::getDefaultXercesMemMgr());
+
+ TranscodeToLocalCodePage(value, theTargetVector, true);
+
+ cout << "Attribute is: " << c_str(theTargetVector) << endl;
}
#endif
@@ -1817,28 +1899,32 @@
{
typedef XalanXMLFileReporter::Hashtable Hashtable;
- Hashtable runResults;
+ MemoryManagerType& theManager = XalanMemMgrs::getDefaultXercesMemMgr();
+
+ Hashtable runResults(theManager);
char temp[5];
// Create entrys that contain runid, xerces version, and numbers for
Pass, Fail and No Gold.
- runResults.insert(Hashtable::value_type(XalanDOMString("UniqRunid"),
runid));
- runResults.insert(Hashtable::value_type(XalanDOMString("Xerces-Version
"), getXercesVersion()));
- runResults.insert(Hashtable::value_type(XalanDOMString("BaseDrive "),
XalanDOMString(getDrive())));
- runResults.insert(Hashtable::value_type(XalanDOMString("TestBase "),
XalanDOMString(args.base)));
- runResults.insert(Hashtable::value_type(XalanDOMString("xmlFormat "),
data.xmlFormat));
+ XalanDOMString theBuffer( theManager);
+
+ runResults.insert( XalanDOMString("UniqRunid",theManager), runid );
+ runResults.insert( XalanDOMString("Xerces-Version ",theManager),
getXercesVersion(theBuffer));
+ runResults.insert( XalanDOMString("BaseDrive ",theManager),
XalanDOMString(getDrive(theBuffer), theManager));
+ runResults.insert( XalanDOMString("TestBase ",theManager),
XalanDOMString(args.base,theManager));
+ runResults.insert( XalanDOMString("xmlFormat ",theManager),
data.xmlFormat);
sprintf(temp, "%ld", args.iters);
- runResults.insert(Hashtable::value_type(XalanDOMString("Iters "),
XalanDOMString(temp)));
+ runResults.insert( XalanDOMString("Iters ",theManager),
XalanDOMString(temp,theManager));
sprintf(temp, "%d", data.pass);
- runResults.insert(Hashtable::value_type(XalanDOMString("Passed"),
XalanDOMString(temp)));
+ runResults.insert( XalanDOMString("Passed",theManager),
XalanDOMString(temp,theManager));
sprintf(temp, "%d", data.fail);
- runResults.insert(Hashtable::value_type(XalanDOMString("Failed"),
XalanDOMString(temp)));
+ runResults.insert( XalanDOMString("Failed",theManager),
XalanDOMString(temp,theManager));
sprintf(temp, "%d", data.nogold);
- runResults.insert(Hashtable::value_type(XalanDOMString("No_Gold_Files"),
XalanDOMString(temp)));
+ runResults.insert( XalanDOMString("No_Gold_Files",theManager),
XalanDOMString(temp,theManager));
logfile.logElementWAttrs(10, "RunResults", runResults, "xxx");
@@ -1857,13 +1943,13 @@
void
XalanFileUtility::analyzeResults(XalanTransformer& xalan, const
XalanDOMString& resultsFile)
{
- XalanDOMString paramValue;
+ XalanDOMString paramValue(XalanMemMgrs::getDefaultXercesMemMgr());
bool fileStatus;
#if defined(AIX) || defined(SOLARIS) || defined(LINUX) || defined(HPUX)
bool pathStatus;
- CharVectorType withPath;
+ CharVectorType withPath(XalanMemMgrs::getDefaultXercesMemMgr());
TranscodeToLocalCodePage(resultsFile, withPath, false);
if (withPath[0] == '/')
pathStatus=true;
@@ -1871,7 +1957,7 @@
pathStatus=false;
char buffer5[PATH_MAX];
- XalanDOMString resultPath= XalanDOMString(getcwd(buffer5, PATH_MAX));
+ XalanDOMString resultPath(getcwd(buffer5, PATH_MAX));
append(resultPath, s_pathSep);
#endif
@@ -1880,33 +1966,42 @@
// quotes so that it is not considered an expression.
//
#if defined (AIX) || defined(SOLARIS) || defined(LINUX) || defined(HPUX)
- assign(paramValue, XalanDOMString("\'"));
+ assign(paramValue, XalanDOMString("\'",
XalanMemMgrs::getDefaultXercesMemMgr()));
if ( !pathStatus )
append(paramValue, resultPath);
append(paramValue, resultsFile);
- append(paramValue, XalanDOMString("\'"));
+ append(paramValue, XalanDOMString("\'",
XalanMemMgrs::getDefaultXercesMemMgr()));
#else
- assign(paramValue, XalanDOMString("'"));
+ assign(paramValue, XalanDOMString("'",
XalanMemMgrs::getDefaultXercesMemMgr()));
append(paramValue, resultsFile);
- append(paramValue, XalanDOMString("'"));
+ append(paramValue, XalanDOMString("'",
XalanMemMgrs::getDefaultXercesMemMgr()));
#endif
// Set the parameter
//
- xalan.setStylesheetParam(XalanDOMString("testfile"), paramValue);
+ xalan.setStylesheetParam(XalanDOMString("testfile",
XalanMemMgrs::getDefaultXercesMemMgr()), paramValue);
// Generate the input and output file names.
//
- const XalanDOMString theHTMLFile = generateFileName(resultsFile,"html",
&fileStatus);
- const XalanDOMString theStylesheet = args.base +
XalanDOMString("cconf.xsl");
- const XalanDOMString theXMLSource = args.base +
XalanDOMString("cconf.xml");
+ XalanDOMString theHTMLFile(XalanMemMgrs::getDefaultXercesMemMgr());
+ generateFileName(resultsFile,"html", theHTMLFile, &fileStatus);
+
+ XalanDOMString theStylesheet(XalanMemMgrs::getDefaultXercesMemMgr());
+ theStylesheet += args.base;
+ theStylesheet += XalanDOMString("cconf.xsl",
XalanMemMgrs::getDefaultXercesMemMgr());
+
+ XalanDOMString theXMLSource(XalanMemMgrs::getDefaultXercesMemMgr());
+ theXMLSource += args.base;
+ theXMLSource += XalanDOMString("cconf.xml",
XalanMemMgrs::getDefaultXercesMemMgr());
// Check that we can find the stylesheet to analyze the results.
//
- FILE* fileHandle = fopen(c_str(TranscodeToLocalCodePage(theStylesheet)),
"r");
+ CharVectorType theBuffer(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(theStylesheet, theBuffer, true);
+ FILE* fileHandle = fopen(c_str(theBuffer), "r");
if (fileHandle == 0)
{
- cout << "ANALYSIS ERROR: File Missing: " <<
c_str(TranscodeToLocalCodePage(theStylesheet)) << endl;
+ cout << "ANALYSIS ERROR: File Missing: " << c_str(theBuffer) << endl;
return;
}
else
@@ -1917,18 +2012,21 @@
// Create the InputSources and ResultTarget.
const XSLTInputSource xslInputSource(theStylesheet);
const XSLTInputSource xmlInputSource(theXMLSource);
- const XSLTResultTarget resultFile(theHTMLFile);
+ const XSLTResultTarget resultFile(theHTMLFile,
XalanMemMgrs::getDefaultXercesMemMgr());
// Do the transform, display the output HTML, or report any failure.
const int result = xalan.transform(xmlInputSource, xslInputSource,
resultFile);
if (result == 0)
{
- #if defined(_MSC_VER)
- system(c_str(TranscodeToLocalCodePage(theHTMLFile)));
- #else
+#if defined(_MSC_VER)
+ CharVectorType theBuffer(XalanMemMgrs::getDefaultXercesMemMgr());
+ TranscodeToLocalCodePage(theHTMLFile, theBuffer, true);
+
+ system(c_str(theBuffer));
+#else
cout << "The HTML output: " << theHTMLFile << " was created" << endl;
- #endif
+#endif
}
else
{
1.2 +29 -27 xml-xalan/c/src/xalanc/Harness/XalanFileUtility.hpp
Index: XalanFileUtility.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/xalanc/Harness/XalanFileUtility.hpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XalanFileUtility.hpp 3 Aug 2004 15:59:09 -0000 1.1
+++ XalanFileUtility.hpp 8 Nov 2004 18:05:41 -0000 1.2
@@ -21,8 +21,7 @@
#include "xalanc/Harness/XalanHarnessDefinitions.hpp"
-
-#include <vector>
+#include "xalanc/Include/XalanVector.hpp"
#if defined(XALAN_CLASSIC_IOSTREAMS)
@@ -60,11 +59,9 @@
public:
// A vector to hold directory names and file names.
-#if defined(XALAN_NO_STD_NAMESPACE)
- typedef vector<XalanDOMString> FileNameVectorType;
-#else
- typedef std::vector<XalanDOMString> FileNameVectorType;
-#endif
+
+ typedef XalanVector<XalanDOMString> FileNameVectorType;
+
struct XALAN_HARNESS_EXPORT reportStruct
{
@@ -81,7 +78,7 @@
int fail;
int nogold;
- reportStruct();
+ reportStruct(MemoryManagerType& theManager);
void
reset();
@@ -111,7 +108,7 @@
long iters;
- cmdParams();
+ cmdParams(MemoryManagerType& theManager);
~cmdParams()
{
@@ -129,7 +126,7 @@
} args;
/** Simple constructor, does not perform initialization. */
- XalanFileUtility();
+ XalanFileUtility(MemoryManagerType& theManager);
~XalanFileUtility();
@@ -138,8 +135,8 @@
* @returns a vector containing test files.
*/
- XalanDOMString
- getDrive();
+ XalanDOMString&
+ getDrive(XalanDOMString& theResult);
bool
getParams(
@@ -149,18 +146,20 @@
bool fsetGold = true);
- FileNameVectorType
+ FileNameVectorType&
getTestFileNames(
const XalanDOMString& baseDir,
const XalanDOMString& relDir,
- bool useDirPrefix);
+ bool useDirPrefix,
+ FileNameVectorType& theFiles);
/**
* Utility method used to get subdirectories from a specific directory.
* @returns a vector containing directory files.
*/
- FileNameVectorType
- getDirectoryNames(const XalanDOMString& rootDirectory);
+ FileNameVectorType&
+ getDirectoryNames(const XalanDOMString& rootDirectory,
+ FileNameVectorType& theFiles);
/**
* Utility method used to create default directories when neccessary
@@ -178,32 +177,34 @@
* Utility method used to get XSL file based on XML file.
* @returns a XalanDOMString.
*/
- XalanDOMString
- getXSLFileName(const XalanDOMString& theXMLFileName);
+ XalanDOMString&
+ getXSLFileName(const XalanDOMString& theXMLFileName,
+ XalanDOMString& theResult);
/**
* Utility method used to get OUT file based on XML file.
* @returns a XalanDOMString.
*/
- XalanDOMString
+ XalanDOMString&
generateFileName(
const XalanDOMString& theXMLFileName,
const char* suffix,
+ XalanDOMString& theResult,
bool* status = 0);
/**
* Utility method used to generate UniqRunid.
* @returns a XalanDOMString.
*/
- XalanDOMString
- generateUniqRunid();
+ XalanDOMString&
+ generateUniqRunid(XalanDOMString& theResult);
/**
* Utility methods used to get Xerces Version number.
* @returns a XalanDOMString.
*/
- XalanDOMString
- getXercesVersion();
+ XalanDOMString&
+ getXercesVersion(XalanDOMString& theResult);
void
@@ -230,11 +231,12 @@
XalanXMLFileReporter& logfile,
const XalanDOMString& outputFile,
const XalanDOMString& goldFile,
+ MemoryManagerType& theManager,
bool containsOnly = false)
{
checkAPIResults(
- XalanDOMString(actual),
- XalanDOMString(expected),
+ XalanDOMString(actual, theManager),
+ XalanDOMString(expected, theManager),
msg,
logfile,
outputFile,
@@ -355,8 +357,8 @@
static const XalanDOMString s_emptyString;
- XalanDOMString
- getProgramName(const char* fullName);
+ XalanDOMString&
+ getProgramName(const char* fullName, XalanDOMString& theBuffer);
/**
* Utility methods used to collect information about compare failures.
1.2 +411 -167 xml-xalan/c/src/xalanc/Harness/XalanXMLFileReporter.cpp
Index: XalanXMLFileReporter.cpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/xalanc/Harness/XalanXMLFileReporter.cpp,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- XalanXMLFileReporter.cpp 3 Aug 2004 15:59:09 -0000 1.1
+++ XalanXMLFileReporter.cpp 8 Nov 2004 18:05:41 -0000 1.2
@@ -32,56 +32,56 @@
-XalanXMLFileReporter::XalanXMLFileReporter(const XalanDOMString& fileName) :
- OPT_FILENAME(),
- ELEM_RESULTSFILE(),
- ELEM_TESTFILE(),
- ELEM_FILERESULT(),
- ELEM_TESTCASE(),
- ELEM_CASERESULT(),
- ELEM_CHECKRESULT(),
- ELEM_STATISTIC(),
- ELEM_LONGVAL(),
- ELEM_DOUBLEVAL(),
- ELEM_MESSAGE(),
- ELEM_ARBITRARY(),
- ELEM_HASHTABLE(),
- ELEM_HASHITEM(),
- ATTR_LEVEL(),
- ATTR_DESC(),
- ATTR_TIME(),
- ATTR_RESULT(),
- ATTR_KEY(),
- ATTR_FILENAME(),
- LESS_THAN(),
- GREATER_THAN(),
- EQUALS_QUOTE(),
- SPACE(),
- QUOTE(),
- QUOTE_SPACE(),
- QUOTE_GREATER_THAN(),
- QUOTE_SOLIDUS_GREATER_THAN(),
- PASS(),
- AMBG(),
- ERRR(),
- FAIL(),
- LESS_THAN_SOLIDUS(),
- XML_HEADER(),
- REASON_EQUALS_QUOTE(),
- TESTCASEINIT_HDR(),
- TESTCASECLOSE_HDR(),
- MESSAGE_HDR(),
- STATISTIC_HDR(),
- ARBITRARY_HDR(),
- HASHTABLE_HDR(),
- HASHITEM_HDR(),
- CHECKPASS_HDR(),
- CHECKAMBG_HDR(),
- CHECKERRR_HDR(),
- CHECKFAIL_HDR(),
- CHECKFAIL_FTR(),
+XalanXMLFileReporter::XalanXMLFileReporter( MemoryManagerType& theManager,
const XalanDOMString& fileName) :
+ OPT_FILENAME(theManager),
+ ELEM_RESULTSFILE(theManager),
+ ELEM_TESTFILE(theManager),
+ ELEM_FILERESULT(theManager),
+ ELEM_TESTCASE(theManager),
+ ELEM_CASERESULT(theManager),
+ ELEM_CHECKRESULT(theManager),
+ ELEM_STATISTIC(theManager),
+ ELEM_LONGVAL(theManager),
+ ELEM_DOUBLEVAL(theManager),
+ ELEM_MESSAGE(theManager),
+ ELEM_ARBITRARY(theManager),
+ ELEM_HASHTABLE(theManager),
+ ELEM_HASHITEM(theManager),
+ ATTR_LEVEL(theManager),
+ ATTR_DESC(theManager),
+ ATTR_TIME(theManager),
+ ATTR_RESULT(theManager),
+ ATTR_KEY(theManager),
+ ATTR_FILENAME(theManager),
+ LESS_THAN(theManager),
+ GREATER_THAN(theManager),
+ EQUALS_QUOTE(theManager),
+ SPACE(theManager),
+ QUOTE(theManager),
+ QUOTE_SPACE(theManager),
+ QUOTE_GREATER_THAN(theManager),
+ QUOTE_SOLIDUS_GREATER_THAN(theManager),
+ PASS(theManager),
+ AMBG(theManager),
+ ERRR(theManager),
+ FAIL(theManager),
+ LESS_THAN_SOLIDUS(theManager),
+ XML_HEADER(theManager),
+ REASON_EQUALS_QUOTE(theManager),
+ TESTCASEINIT_HDR(theManager),
+ TESTCASECLOSE_HDR(theManager),
+ MESSAGE_HDR(theManager),
+ STATISTIC_HDR(theManager),
+ ARBITRARY_HDR(theManager),
+ HASHTABLE_HDR(theManager),
+ HASHITEM_HDR(theManager),
+ CHECKPASS_HDR(theManager),
+ CHECKAMBG_HDR(theManager),
+ CHECKERRR_HDR(theManager),
+ CHECKFAIL_HDR(theManager),
+ CHECKFAIL_FTR(theManager),
m_anyOutput(false),
- m_fileName(fileName),
+ m_fileName(fileName, theManager),
m_fileHandle(0),
m_ready(false),
m_error(false),
@@ -89,12 +89,12 @@
{
if (m_fileName.empty() == false)
{
- m_ready = initialize();
+ m_ready = initialize(theManager);
}
}
bool
-XalanXMLFileReporter::initialize()
+XalanXMLFileReporter::initialize(MemoryManagerType& theManager)
{
if (m_fileName.empty() == true)
{
@@ -106,7 +106,7 @@
else
{
// Transcode down the file name...
- CharVectorType theTranscodedFileName;
+ CharVectorType theTranscodedFileName(theManager);
TranscodeToLocalCodePage(m_fileName, theTranscodedFileName, true);
@@ -223,10 +223,27 @@
void
XalanXMLFileReporter::logTestFileInit(const XalanDOMString& msg)
{
+ XalanDOMString b(getMemoryManager());
if (isReady())
{
- printToFile(LESS_THAN + ELEM_TESTFILE
- + SPACE + ATTR_DESC + EQUALS_QUOTE +
escapestring(msg) + QUOTE_SPACE + ATTR_TIME + EQUALS_QUOTE +
getDateTimeString() + QUOTE_GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b += LESS_THAN;
+ b += ELEM_TESTFILE;
+ b += SPACE;
+ b +=ATTR_DESC;
+ b +=EQUALS_QUOTE;
+ b +=escapestring(msg, buffer);
+ b +=QUOTE_SPACE;
+ b +=ATTR_TIME;
+ b +=EQUALS_QUOTE;
+ buffer.clear();
+ b +=getDateTimeString(buffer);
+ b +=QUOTE_GREATER_THAN;
+
+
+ printToFile(b);
}
}
@@ -237,9 +254,12 @@
{
if (isReady())
{
-// printToFile(LESS_THAN + ELEM_FILERESULT
-// + SPACE + ATTR_DESC + EQUALS_QUOTE +
escapestring(msg) + QUOTE_SPACE + ATTR_RESULT + EQUALS_QUOTE + result +
QUOTE_SPACE + ATTR_TIME + EQUALS_QUOTE + getDateTimeString() +
QUOTE_SOLIDUS_GREATER_THAN);
- printToFile(LESS_THAN_SOLIDUS + ELEM_TESTFILE + GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ b +=LESS_THAN_SOLIDUS;
+ b +=ELEM_TESTFILE;
+ b +=GREATER_THAN;
+
+ printToFile(b);
}
flush();
}
@@ -251,7 +271,14 @@
{
if (isReady())
{
- printToFile(TESTCASEINIT_HDR + escapestring(msg) +
QUOTE_GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b +=TESTCASEINIT_HDR;
+ b +=escapestring(msg, buffer);
+ b +=QUOTE_GREATER_THAN;
+
+ printToFile(b);
}
}
@@ -262,8 +289,12 @@
{
if (isReady())
{
- //printToFile(TESTCASECLOSE_HDR + escapestring(msg) + QUOTE_SPACE +
ATTR_RESULT + EQUALS_QUOTE + result + QUOTE_SOLIDUS_GREATER_THAN);
- printToFile(LESS_THAN_SOLIDUS + ELEM_TESTCASE + GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ b +=LESS_THAN_SOLIDUS;
+ b +=ELEM_TESTCASE;
+ b +=GREATER_THAN;
+
+ printToFile(b);
}
if (getFlushOnCaseClose())
{
@@ -281,48 +312,71 @@
if (isReady())
{
- printToFile(MESSAGE_HDR + tmp + QUOTE_GREATER_THAN);
- printToFile(escapestring(msg));
- printToFile(LESS_THAN_SOLIDUS + ELEM_MESSAGE + GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b +=LESS_THAN_SOLIDUS;
+ b +=MESSAGE_HDR;
+ b.append(tmp);
+ b +=QUOTE_GREATER_THAN;
+
+ printToFile(b);
+ printToFile(escapestring(msg, buffer));
+ b.clear();
+ b +=LESS_THAN_SOLIDUS;
+ b +=ELEM_MESSAGE;
+ b +=GREATER_THAN;
+
+ printToFile(b );
}
}
-void XalanXMLFileReporter::addMetricToAttrs(char* desc, double theMetric,
Hashtable& attrs)
+void
+XalanXMLFileReporter::addMetricToAttrs(char* desc, double theMetric,
Hashtable& attrs)
{
- XalanDOMString temp;
+ XalanDOMString temp(getMemoryManager());
DoubleToDOMString(theMetric, temp);
- attrs.insert(Hashtable::value_type(XalanDOMString(desc), temp));
- return;
+ attrs.insert(XalanDOMString(desc,getMemoryManager()) ,temp);
+
}
void
-XalanXMLFileReporter::logElementWAttrs(int /* level */, const
XalanDOMString& element, Hashtable attrs, const XalanDOMString& msg)
+XalanXMLFileReporter::logElementWAttrs(int /* level */, const
XalanDOMString& element, Hashtable& attrs, const XalanDOMString& msg)
{
if (isReady() && !element.empty()&& !attrs.empty())
{
-// char tmp[20];
-// sprintf(tmp, "%d", level);
-//
-// Took out this level attribute cuz we don't use it.
-// printToFile(LESS_THAN + element + SPACE + ATTR_LEVEL + EQUALS_QUOTE
-// + tmp + QUOTE);
- printToFile(LESS_THAN + element + SPACE);
+
+ XalanDOMString b(getMemoryManager());
+ b +=LESS_THAN;
+ b +=element;
+ b +=SPACE;
+ printToFile( b);
Hashtable::iterator theEnd = attrs.end();
for(Hashtable::iterator i = attrs.begin(); i != theEnd; ++i)
{
-
- printToFile((*i).first + EQUALS_QUOTE
- + (*i).second + QUOTE);
+ b.erase();
+ b +=(*i).first;
+ b +=EQUALS_QUOTE;
+ b +=(*i).second ;
+ b +=QUOTE;
+ printToFile(b);
}
printToFile(GREATER_THAN);
if (msg.empty() != 0)
- printToFile(escapestring(msg));
- printToFile(LESS_THAN_SOLIDUS + element + GREATER_THAN);
+ {
+ XalanDOMString theResult( getMemoryManager());
+ printToFile(escapestring(msg,theResult ));
+ }
+ b.erase();
+ b +=LESS_THAN_SOLIDUS;
+ b +=element;
+ b +=GREATER_THAN;
+ printToFile(b);
}
}
@@ -331,7 +385,18 @@
{
if (isReady() && !element.empty() && !msg.empty())
{
- printToFile(LESS_THAN + element + GREATER_THAN + escapestring(msg) +
LESS_THAN_SOLIDUS + element + GREATER_THAN);
+ XalanDOMString theString( getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ theString += LESS_THAN;
+ theString += element;
+ theString +=GREATER_THAN;
+ theString +=escapestring(msg, buffer);
+ theString +=LESS_THAN_SOLIDUS;
+ theString +=element;
+ theString +=GREATER_THAN;
+
+ printToFile(theString);
}
}
@@ -340,18 +405,53 @@
{
if (isReady())
{
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
char tmp[40];
sprintf(tmp, "%d", level);
- printToFile(STATISTIC_HDR + tmp + QUOTE_SPACE + ATTR_DESC +
EQUALS_QUOTE + escapestring(msg) + QUOTE_GREATER_THAN);
+ b += STATISTIC_HDR;
+ b += XalanDOMString(tmp, getMemoryManager());
+ b += QUOTE_SPACE;
+ b += ATTR_DESC;
+ b += EQUALS_QUOTE;
+ b += escapestring(msg,buffer);
+ b += QUOTE_GREATER_THAN;
+
+ printToFile(b);
+ b.clear();
sprintf(tmp, "%ld", lVal);
- printToFile(LESS_THAN + ELEM_LONGVAL + GREATER_THAN + tmp +
LESS_THAN_SOLIDUS + ELEM_LONGVAL + GREATER_THAN);
-
+
+ b += LESS_THAN;
+ b += ELEM_LONGVAL;
+ b += GREATER_THAN;
+ b += XalanDOMString(tmp, getMemoryManager());
+ b += LESS_THAN_SOLIDUS;
+ b += ELEM_LONGVAL;
+ b += GREATER_THAN;
+
+ printToFile(b);
+ b.clear();
+
sprintf(tmp, "%f", dVal);
- printToFile(LESS_THAN + ELEM_DOUBLEVAL + GREATER_THAN + tmp +
LESS_THAN_SOLIDUS + ELEM_DOUBLEVAL + GREATER_THAN);
-
- printToFile(LESS_THAN_SOLIDUS + ELEM_STATISTIC + GREATER_THAN);
+
+ b += LESS_THAN;
+ b += XalanDOMString(ELEM_DOUBLEVAL, getMemoryManager());
+ b += GREATER_THAN;
+ b += XalanDOMString(tmp, getMemoryManager());
+ b += LESS_THAN_SOLIDUS;
+ b += ELEM_DOUBLEVAL;
+ b += GREATER_THAN;
+
+ printToFile(b);
+ b.clear();
+
+ b += LESS_THAN_SOLIDUS;
+ b += ELEM_STATISTIC;
+ b += GREATER_THAN;
+
+ printToFile(b);
}
}
@@ -365,10 +465,24 @@
sprintf(tmp, "%d", level);
if (isReady())
- {
- printToFile(ARBITRARY_HDR + tmp + QUOTE_GREATER_THAN);
- printToFile(escapestring(msg));
- printToFile(LESS_THAN_SOLIDUS + ELEM_ARBITRARY + GREATER_THAN);
+ {
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b += ARBITRARY_HDR;
+ b += XalanDOMString(tmp,getMemoryManager());
+ b += QUOTE_GREATER_THAN;
+
+ printToFile(b);
+
+ printToFile(escapestring(msg, buffer));
+
+ b.clear();
+ b +=LESS_THAN_SOLIDUS;
+ b +=ELEM_ARBITRARY;
+ b +=GREATER_THAN;
+
+ printToFile(b);
}
}
@@ -411,7 +525,13 @@
{
if (isReady())
{
- printToFile(CHECKPASS_HDR + escapestring(comment) +
QUOTE_SOLIDUS_GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+ b += CHECKPASS_HDR;
+ b += escapestring(comment,buffer);
+ b +=QUOTE_SOLIDUS_GREATER_THAN;
+
+ printToFile(b);
}
}
@@ -421,23 +541,37 @@
{
if (isReady())
{
- printToFile(CHECKFAIL_HDR + escapestring(comment) +
QUOTE_SOLIDUS_GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b+= CHECKFAIL_HDR;
+ b+=escapestring(comment, buffer);
+ b+= QUOTE_SOLIDUS_GREATER_THAN;
+
+ printToFile(b);
}
}
void
-XalanXMLFileReporter::logCheckFail(const XalanDOMString& test, Hashtable
actexp)
+XalanXMLFileReporter::logCheckFail(const XalanDOMString& test, const
Hashtable& actexp)
{
if (isReady())
{
- printToFile(CHECKFAIL_HDR + escapestring(test) + QUOTE);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b+= CHECKFAIL_HDR;
+ b+= escapestring(test, buffer);
+ b+= QUOTE;
+
+ printToFile(b);
printToFile(GREATER_THAN);
- Hashtable::iterator aeEnd = actexp.end();
- for(Hashtable::iterator ii = actexp.begin(); ii != aeEnd; ++ii)
+ Hashtable::const_iterator aeEnd = actexp.end();
+ for(Hashtable::const_iterator ii = actexp.begin(); ii != aeEnd; ++ii)
{
logElement((*ii).first, (*ii).second);
}
@@ -447,23 +581,31 @@
}
void
-XalanXMLFileReporter::logCheckFail(const XalanDOMString& test, Hashtable
attrs, Hashtable actexp)
+XalanXMLFileReporter::logCheckFail(const XalanDOMString& test, const
Hashtable& attrs, const Hashtable& actexp)
{
if (isReady())
{
- printToFile(CHECKFAIL_HDR + escapestring(test) + QUOTE);
-
- Hashtable::iterator fdEnd = attrs.end();
- for(Hashtable::iterator i = attrs.begin(); i != fdEnd; ++i)
- {
- printToFile((*i).first + EQUALS_QUOTE
- + (*i).second + QUOTE);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+ b+= CHECKFAIL_HDR;
+ b+= escapestring(test, buffer);
+ b+= QUOTE;
+ printToFile(b);
+
+ Hashtable::const_iterator fdEnd = attrs.end();
+ for(Hashtable::const_iterator i = attrs.begin(); i != fdEnd; ++i)
+ {
+ b.clear();
+ b += (*i).first;
+ b += EQUALS_QUOTE;
+ b += QUOTE;
+ printToFile(b);
}
printToFile(GREATER_THAN);
- Hashtable::iterator aeEnd = actexp.end();
- for(Hashtable::iterator ii = actexp.begin(); ii != aeEnd; ++ii)
+ Hashtable::const_iterator aeEnd = actexp.end();
+ for(Hashtable::const_iterator ii = actexp.begin(); ii != aeEnd; ++ii)
{
logElement((*ii).first, (*ii).second);
}
@@ -477,7 +619,14 @@
{
if (isReady())
{
- printToFile(CHECKAMBG_HDR + escapestring(comment) +
QUOTE_SOLIDUS_GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b += CHECKAMBG_HDR;
+ b += escapestring(comment, buffer);
+ b += QUOTE_SOLIDUS_GREATER_THAN;
+
+ printToFile(b);
}
}
@@ -487,7 +636,17 @@
{
if (isReady())
{
- printToFile(CHECKFAIL_HDR + escapestring(test) + QUOTE_SPACE +
XalanDOMString(REASON_EQUALS_QUOTE) + escapestring(reason) +
QUOTE_SOLIDUS_GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b += CHECKFAIL_HDR;
+ b += escapestring(test, buffer);
+ b += QUOTE_SPACE;
+ b += XalanDOMString(REASON_EQUALS_QUOTE, getMemoryManager());
+ buffer.clear();
+ b += escapestring(reason, buffer);
+ b += QUOTE_SOLIDUS_GREATER_THAN;
+ printToFile( b);
}
}
@@ -498,7 +657,13 @@
{
if (isReady())
{
- printToFile(CHECKERRR_HDR + escapestring(comment) +
QUOTE_SOLIDUS_GREATER_THAN);
+ XalanDOMString b(getMemoryManager());
+ XalanDOMString buffer(getMemoryManager());
+
+ b += CHECKERRR_HDR;
+ b += escapestring(comment, buffer);
+ b += QUOTE_SOLIDUS_GREATER_THAN;
+ printToFile(b);
}
}
@@ -564,10 +729,9 @@
-XalanDOMString
-XalanXMLFileReporter::escapestring(const XalanDOMString& s)
+XalanDOMString&
+XalanXMLFileReporter::escapestring(const XalanDOMString& s, XalanDOMString&
sb)
{
- XalanDOMString sb;
const XalanDOMString::size_type length = s.length();
@@ -617,7 +781,17 @@
printToFile(XML_HEADER);
// Note: this tag is closed in our .close() method, which the caller
had better call!
- printToFile(LESS_THAN + ELEM_RESULTSFILE + SPACE + ATTR_FILENAME +
EQUALS_QUOTE + m_fileName + QUOTE_GREATER_THAN);
+
+ XalanDOMString b(getMemoryManager());
+ b += LESS_THAN;
+ b += ELEM_RESULTSFILE;
+ b += SPACE;
+ b += ATTR_FILENAME;
+ b += EQUALS_QUOTE;
+ b += m_fileName;
+ b += QUOTE_GREATER_THAN;
+
+ printToFile(b);
return true;
}
@@ -637,8 +811,13 @@
return false;
}
else
- {
- printToFile(LESS_THAN_SOLIDUS + ELEM_RESULTSFILE + GREATER_THAN);
+ {
+ XalanDOMString b(getMemoryManager());
+ b += LESS_THAN_SOLIDUS;
+ b += ELEM_RESULTSFILE;
+ b += GREATER_THAN;
+
+ printToFile(b);
return true;
}
}
@@ -653,7 +832,8 @@
}
else
{
- const CharVectorType theResult(TranscodeToLocalCodePage(output));
+ CharVectorType theResult(getMemoryManager());
+ TranscodeToLocalCodePage(output, theResult, true);
if(!theResult.size())
{
@@ -672,8 +852,8 @@
-XalanDOMString
-XalanXMLFileReporter::getDateTimeString()
+XalanDOMString &
+XalanXMLFileReporter::getDateTimeString(XalanDOMString& theResult)
{
#if defined(XALAN_STRICT_ANSI_HEADERS)
using std::tm;
@@ -691,7 +871,9 @@
const char* const theTime = asctime(tmNow);
- return XalanDOMString(theTime, XalanDOMString::length(theTime) - 1);
+ theResult.assign(theTime, XalanDOMString::length(theTime) - 1);
+
+ return theResult;
}
@@ -699,54 +881,116 @@
void
XalanXMLFileReporter::initStrings()
{
- OPT_FILENAME = XALAN_STATIC_UCODE_STRING("filename");
- ELEM_RESULTSFILE = XALAN_STATIC_UCODE_STRING("resultsfile");
- ELEM_TESTFILE = XALAN_STATIC_UCODE_STRING("testfile");
- ELEM_FILERESULT = XALAN_STATIC_UCODE_STRING("fileresult");
- ELEM_TESTCASE = XALAN_STATIC_UCODE_STRING("Test_Dir");
- ELEM_CASERESULT = XALAN_STATIC_UCODE_STRING("Dir-result");
- ELEM_CHECKRESULT = XALAN_STATIC_UCODE_STRING("Testcase");
- ELEM_STATISTIC = XALAN_STATIC_UCODE_STRING("statistic");
- ELEM_LONGVAL = XALAN_STATIC_UCODE_STRING("longval");
- ELEM_DOUBLEVAL = XALAN_STATIC_UCODE_STRING("doubleval");
- ELEM_MESSAGE = XALAN_STATIC_UCODE_STRING("message");
- ELEM_ARBITRARY = XALAN_STATIC_UCODE_STRING("arbitrary");
- ELEM_HASHTABLE = XALAN_STATIC_UCODE_STRING("hashtable");
- ELEM_HASHITEM = XALAN_STATIC_UCODE_STRING("hashitem");
- ATTR_LEVEL = XALAN_STATIC_UCODE_STRING("level");
- ATTR_DESC = XALAN_STATIC_UCODE_STRING("desc");
- ATTR_TIME = XALAN_STATIC_UCODE_STRING("time");
- ATTR_RESULT = XALAN_STATIC_UCODE_STRING("result");
- ATTR_KEY = XALAN_STATIC_UCODE_STRING("key");
+ OPT_FILENAME = XalanDOMString("filename", getMemoryManager());
+ ELEM_RESULTSFILE = XalanDOMString("resultsfile", getMemoryManager());
+ ELEM_TESTFILE = XalanDOMString("testfile", getMemoryManager());
+ ELEM_FILERESULT = XalanDOMString("fileresult", getMemoryManager());
+ ELEM_TESTCASE = XalanDOMString("Test_Dir", getMemoryManager());
+ ELEM_CASERESULT = XalanDOMString("Dir-result", getMemoryManager());
+ ELEM_CHECKRESULT = XalanDOMString("Testcase", getMemoryManager());
+ ELEM_STATISTIC = XalanDOMString("statistic", getMemoryManager());
+ ELEM_LONGVAL = XalanDOMString("longval", getMemoryManager());
+ ELEM_DOUBLEVAL = XalanDOMString("doubleval", getMemoryManager());
+ ELEM_MESSAGE = XalanDOMString("message", getMemoryManager());
+ ELEM_ARBITRARY = XalanDOMString("arbitrary", getMemoryManager());
+ ELEM_HASHTABLE = XalanDOMString("hashtable", getMemoryManager());
+ ELEM_HASHITEM = XalanDOMString("hashitem", getMemoryManager());
+ ATTR_LEVEL = XalanDOMString("level", getMemoryManager());
+ ATTR_DESC = XalanDOMString("desc", getMemoryManager());
+ ATTR_TIME = XalanDOMString("time", getMemoryManager());
+ ATTR_RESULT = XalanDOMString("result", getMemoryManager());
+ ATTR_KEY = XalanDOMString("key", getMemoryManager());
ATTR_FILENAME = OPT_FILENAME;
- LESS_THAN = XALAN_STATIC_UCODE_STRING("<");
- GREATER_THAN = XALAN_STATIC_UCODE_STRING(">");
- EQUALS_QUOTE = XALAN_STATIC_UCODE_STRING("=\"");
- SPACE = XALAN_STATIC_UCODE_STRING(" ");
- QUOTE = XALAN_STATIC_UCODE_STRING("\"");
- QUOTE_SPACE = XALAN_STATIC_UCODE_STRING("\" ");
- QUOTE_GREATER_THAN = XALAN_STATIC_UCODE_STRING("\">");
- QUOTE_SOLIDUS_GREATER_THAN = XALAN_STATIC_UCODE_STRING("\"/>");
- PASS = XALAN_STATIC_UCODE_STRING("PASS");
- AMBG = XALAN_STATIC_UCODE_STRING("AMBG");
- ERRR = XALAN_STATIC_UCODE_STRING("ERRR");
- FAIL = XALAN_STATIC_UCODE_STRING("FAIL");
- LESS_THAN_SOLIDUS = XALAN_STATIC_UCODE_STRING("</");
- XML_HEADER = XALAN_STATIC_UCODE_STRING("<?xml version=\"1.0\"?>");
- REASON_EQUALS_QUOTE = XALAN_STATIC_UCODE_STRING("reason=\"");
-
- TESTCASEINIT_HDR = LESS_THAN + ELEM_TESTCASE + SPACE + ATTR_DESC +
EQUALS_QUOTE;
- TESTCASECLOSE_HDR = LESS_THAN + ELEM_CASERESULT + SPACE + ATTR_DESC +
EQUALS_QUOTE;
- MESSAGE_HDR = LESS_THAN + ELEM_MESSAGE + SPACE + ATTR_LEVEL +
EQUALS_QUOTE;
- STATISTIC_HDR = LESS_THAN + ELEM_STATISTIC + SPACE + ATTR_LEVEL +
EQUALS_QUOTE;
- ARBITRARY_HDR = LESS_THAN + ELEM_ARBITRARY + SPACE + ATTR_LEVEL +
EQUALS_QUOTE;
- HASHTABLE_HDR = LESS_THAN + ELEM_HASHTABLE + SPACE + ATTR_LEVEL +
EQUALS_QUOTE;
- HASHITEM_HDR = LESS_THAN + ELEM_HASHITEM + SPACE + ATTR_KEY +
EQUALS_QUOTE;
- CHECKPASS_HDR = LESS_THAN + ELEM_CHECKRESULT + SPACE + ATTR_RESULT +
EQUALS_QUOTE + PASS + QUOTE_SPACE + ATTR_DESC + EQUALS_QUOTE;
- CHECKAMBG_HDR = LESS_THAN + ELEM_CHECKRESULT + SPACE + ATTR_RESULT +
EQUALS_QUOTE + AMBG + QUOTE_SPACE + ATTR_DESC + EQUALS_QUOTE;
- CHECKERRR_HDR = LESS_THAN + ELEM_CHECKRESULT + SPACE + ATTR_RESULT +
EQUALS_QUOTE + ERRR + QUOTE_SPACE + ATTR_DESC + EQUALS_QUOTE;
- CHECKFAIL_HDR = LESS_THAN + ELEM_CHECKRESULT + SPACE + ATTR_RESULT +
EQUALS_QUOTE + FAIL + QUOTE_SPACE + ATTR_DESC + EQUALS_QUOTE;
- CHECKFAIL_FTR = LESS_THAN_SOLIDUS + ELEM_CHECKRESULT + GREATER_THAN;
+ LESS_THAN = XalanDOMString("<", getMemoryManager());
+ GREATER_THAN = XalanDOMString(">", getMemoryManager());
+ EQUALS_QUOTE = XalanDOMString("=\"", getMemoryManager());
+ SPACE = XalanDOMString(" ", getMemoryManager());
+ QUOTE = XalanDOMString("\"", getMemoryManager());
+ QUOTE_SPACE = XalanDOMString("\" ", getMemoryManager());
+ QUOTE_GREATER_THAN = XalanDOMString("\">", getMemoryManager());
+ QUOTE_SOLIDUS_GREATER_THAN = XalanDOMString("\"/>", getMemoryManager());
+ PASS = XalanDOMString("PASS", getMemoryManager());
+ AMBG = XalanDOMString("AMBG", getMemoryManager());
+ ERRR = XalanDOMString("ERRR", getMemoryManager());
+ FAIL = XalanDOMString("FAIL", getMemoryManager());
+ LESS_THAN_SOLIDUS = XalanDOMString("</", getMemoryManager());
+ XML_HEADER = XalanDOMString("<?xml version=\"1.0\"?>",
getMemoryManager());
+ REASON_EQUALS_QUOTE = XalanDOMString("reason=\"", getMemoryManager());
+
+ TESTCASEINIT_HDR = LESS_THAN;
+ TESTCASEINIT_HDR += ELEM_TESTCASE ;
+ TESTCASEINIT_HDR += SPACE;
+ TESTCASEINIT_HDR += ATTR_DESC;
+ TESTCASEINIT_HDR += EQUALS_QUOTE;
+
+ TESTCASECLOSE_HDR = LESS_THAN;
+ TESTCASECLOSE_HDR += ELEM_CASERESULT;
+ TESTCASECLOSE_HDR += SPACE;
+ TESTCASECLOSE_HDR += ATTR_DESC;
+ TESTCASECLOSE_HDR += EQUALS_QUOTE;
+
+ MESSAGE_HDR = LESS_THAN;
+ MESSAGE_HDR += ELEM_MESSAGE;
+ MESSAGE_HDR += SPACE;
+ MESSAGE_HDR += ATTR_LEVEL;
+ MESSAGE_HDR += EQUALS_QUOTE;
+
+ STATISTIC_HDR +=LESS_THAN;
+ STATISTIC_HDR +=ELEM_STATISTIC;
+ STATISTIC_HDR +=SPACE;
+ STATISTIC_HDR +=ATTR_LEVEL;
+ STATISTIC_HDR +=EQUALS_QUOTE;
+
+ ARBITRARY_HDR += LESS_THAN;
+ ARBITRARY_HDR += ELEM_ARBITRARY;
+ ARBITRARY_HDR += SPACE;
+ ARBITRARY_HDR += ATTR_LEVEL;
+ ARBITRARY_HDR += EQUALS_QUOTE;
+
+ HASHTABLE_HDR += LESS_THAN;
+ HASHTABLE_HDR += ELEM_HASHTABLE;
+ HASHTABLE_HDR += SPACE;
+ HASHTABLE_HDR += ATTR_LEVEL;
+ HASHTABLE_HDR += EQUALS_QUOTE;
+
+ HASHITEM_HDR += LESS_THAN;
+ HASHITEM_HDR += ELEM_HASHITEM;
+ HASHITEM_HDR += SPACE;
+ HASHITEM_HDR += ATTR_KEY;
+ HASHITEM_HDR += EQUALS_QUOTE;
+
+ XalanDOMString prefix(getMemoryManager()), suffix(getMemoryManager());
+
+ prefix += LESS_THAN;
+ prefix += ELEM_CHECKRESULT;
+ prefix += SPACE;
+ prefix += ATTR_RESULT;
+ prefix += EQUALS_QUOTE;
+
+ suffix += QUOTE_SPACE;
+ suffix += ATTR_DESC;
+ suffix += EQUALS_QUOTE;
+
+ CHECKPASS_HDR += prefix;
+ CHECKPASS_HDR += PASS;
+ CHECKPASS_HDR += suffix;
+
+ CHECKAMBG_HDR += prefix;
+ CHECKAMBG_HDR += AMBG;
+ CHECKAMBG_HDR += suffix;
+
+ CHECKERRR_HDR += prefix;
+ CHECKERRR_HDR += ERRR;
+ CHECKERRR_HDR += suffix;
+
+ CHECKFAIL_HDR += prefix;
+ CHECKFAIL_HDR += FAIL;
+ CHECKFAIL_HDR += suffix;
+
+ CHECKFAIL_FTR += LESS_THAN_SOLIDUS;
+ CHECKFAIL_FTR += ELEM_CHECKRESULT;
+ CHECKFAIL_FTR += GREATER_THAN;
+
}
1.3 +28 -19 xml-xalan/c/src/xalanc/Harness/XalanXMLFileReporter.hpp
Index: XalanXMLFileReporter.hpp
===================================================================
RCS file: /home/cvs/xml-xalan/c/src/xalanc/Harness/XalanXMLFileReporter.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- XalanXMLFileReporter.hpp 28 Sep 2004 18:48:58 -0000 1.2
+++ XalanXMLFileReporter.hpp 8 Nov 2004 18:05:41 -0000 1.3
@@ -28,7 +28,7 @@
#include "xalanc/Include/XalanMap.hpp"
-
+#include "xalanc/Include/XalanMemMgrHelper.hpp"
#include "xalanc/PlatformSupport/DOMStringHelper.hpp"
@@ -42,9 +42,10 @@
-// This class is exported from the Harness.dll
+
class XALAN_HARNESS_EXPORT XalanXMLFileReporter
{
+
public:
typedef XalanMap<XalanDOMString, XalanDOMString> Hashtable;
@@ -60,10 +61,16 @@
// Construct and initialize this reporter with specified filename, if
// the filename is not empty.
- XalanXMLFileReporter(const XalanDOMString& fileName = XalanDOMString());
+ XalanXMLFileReporter(MemoryManagerType& theManager, const
XalanDOMString& fileName);
// Initialize this XalanXMLFileReporter. Must be called before
attempting to log anything.
- bool initialize();
+ bool initialize(MemoryManagerType& theManager);
+
+ MemoryManagerType&
+ getMemoryManager()
+ {
+ return m_fileName.getMemoryManager();
+ }
// Accessor for flushing; is set from properties.
bool getFlushOnCaseClose();
@@ -75,9 +82,9 @@
void setFileName(const XalanDOMString& fileName);
// Accessor methods for our properties block.
- void setFileName(const char* fileName)
+ void setFileName(const char* fileName, MemoryManagerType& theManager)
{
- setFileName(XalanDOMString(fileName));
+ setFileName(XalanDOMString(fileName, theManager));
}
//
@@ -110,7 +117,7 @@
void logTestFileInit(const char* msg)
{
- logTestFileInit(XalanDOMString(msg));
+ logTestFileInit(XalanDOMString(msg, getMemoryManager()));
}
/**
@@ -122,14 +129,14 @@
void logTestFileClose(const char* msg, const char* result)
{
- logTestFileClose(XalanDOMString(msg), XalanDOMString(result));
+ logTestFileClose(XalanDOMString(msg, getMemoryManager()),
XalanDOMString(result, getMemoryManager()));
}
void logTestCaseInit(const XalanDOMString& msg);
void logTestCaseInit(const char* msg)
{
- logTestCaseInit(XalanDOMString(msg));
+ logTestCaseInit(XalanDOMString(msg, getMemoryManager()));
}
/**
@@ -141,7 +148,7 @@
void logTestCaseClose(const char* msg, const char* result)
{
- logTestCaseClose(XalanDOMString(msg), XalanDOMString(result));
+ logTestCaseClose(XalanDOMString(msg , getMemoryManager()),
XalanDOMString(result , getMemoryManager()));
}
//-----------------------------------------------------
//-------- Test results reporting and logging routines --------
@@ -168,7 +175,7 @@
void logStatistic (int level, long lVal, double dVal, const char* msg)
{
- logStatistic(level, lVal, dVal, XalanDOMString(msg));
+ logStatistic(level, lVal, dVal, XalanDOMString(msg,
getMemoryManager()));
}
// This routine will add an attribute to the attribute list.
@@ -185,11 +192,11 @@
* caller must ensure they're legal XML
* @param msg comment to log out.
*/
- void logElementWAttrs(int level, const XalanDOMString& element,
Hashtable attrs, const XalanDOMString& msg);
+ void logElementWAttrs(int level, const XalanDOMString& element,
Hashtable& attrs, const XalanDOMString& msg);
- void logElementWAttrs(int level, const char* element, Hashtable attrs,
const char* msg)
+ void logElementWAttrs(int level, const char* element, Hashtable& attrs,
const char* msg)
{
- logElementWAttrs(level, XalanDOMString(element), attrs,
XalanDOMString(msg));
+ logElementWAttrs(level, XalanDOMString(element, getMemoryManager()),
attrs, XalanDOMString(msg, getMemoryManager()));
}
void logElement(int level, const XalanDOMString& element, const
XalanDOMString& msg);
@@ -245,9 +252,9 @@
*/
void logCheckFail(const XalanDOMString& comment);
- void logCheckFail(const XalanDOMString& test, Hashtable faildata,
Hashtable actexp);
+ void logCheckFail(const XalanDOMString& test, const Hashtable& faildata,
const Hashtable& actexp);
- void logCheckFail(const XalanDOMString& test, Hashtable actexp);
+ void logCheckFail(const XalanDOMString& test, const Hashtable& actexp);
void logErrorResult(const XalanDOMString& test, const XalanDOMString&
reason);
@@ -264,11 +271,12 @@
* @param s XalanDOMString to escape.
* @return XalanDOMString that has been escaped.
*/
- XalanDOMString escapestring(const XalanDOMString& s);
+ XalanDOMString& escapestring(const XalanDOMString& s, XalanDOMString&
buffer);
private:
-
+ // not implemented
+ XalanXMLFileReporter(const XalanXMLFileReporter&);
/**
* worker method to dump the xml header and open the resultsfile element.
*/
@@ -290,7 +298,8 @@
/**
* worker method to prints to the resultsfile.
*/
- XalanDOMString getDateTimeString();
+ XalanDOMString&
+ getDateTimeString(XalanDOMString& result);
/** Key for Properties block that denotes our output filename. */
XalanDOMString OPT_FILENAME;
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
