| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "XalanXMLFileReporter.hpp" |
| |
| |
| |
| #include <cstdlib> |
| #include <ctime> |
| |
| |
| |
| #include "xalanc/PlatformSupport/DOMStringHelper.hpp" |
| #include <xalanc/PlatformSupport/XalanMessageLoader.hpp> |
| #include "xalanc/PlatformSupport/XalanTranscodingServices.hpp" |
| #include "xalanc/PlatformSupport/XalanUnicode.hpp" |
| #include <xalanc/PlatformSupport/XSLException.hpp> |
| |
| |
| |
| namespace XALAN_CPP_NAMESPACE { |
| |
| |
| |
| using std::fclose; |
| using std::fflush; |
| using std::fopen; |
| using std::fprintf; |
| using std::fputs; |
| using std::sprintf; |
| |
| |
| |
| XalanOutputTranscoder* |
| makeNewUTF8Transcoder(MemoryManager& theMemoryManager) |
| { |
| XalanTranscodingServices::eCode theCode; |
| |
| XalanOutputTranscoder* const theTranscoder = |
| XalanTranscodingServices::makeNewTranscoder( |
| theMemoryManager, |
| XalanTranscodingServices::s_utf8String, |
| theCode, |
| 1024); |
| |
| if (theCode != XalanTranscodingServices::OK) |
| { |
| XalanDOMString theBuffer(theMemoryManager); |
| |
| throw XalanTranscodingServices::MakeTranscoderException( |
| theCode, |
| XalanTranscodingServices::s_utf8String, |
| theBuffer); |
| } |
| |
| return theTranscoder; |
| } |
| |
| |
| |
| XalanXMLFileReporter::XalanXMLFileReporter( MemoryManager& 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, theManager), |
| m_fileHandle(0), |
| m_ready(false), |
| m_error(false), |
| m_flushOnCaseClose(true), |
| m_transcoder(makeNewUTF8Transcoder(theManager)), |
| m_buffer(theManager) |
| { |
| assert(m_transcoder.get() != 0); |
| |
| if (m_fileName.empty() == false) |
| { |
| m_ready = initialize(theManager); |
| } |
| } |
| |
| |
| |
| XalanXMLFileReporter::~XalanXMLFileReporter() |
| { |
| } |
| |
| |
| |
| bool |
| XalanXMLFileReporter::initialize(MemoryManager& /* theManager */) |
| { |
| if (m_fileName.empty() == true) |
| { |
| // We don't have a valid file, so bail |
| m_error = true; |
| m_ready = false; |
| fprintf(stderr, "XalanXMLFileReporter.initialize() ERROR: No file name specified"); |
| } |
| else |
| { |
| // Transcode down the file name... |
| TranscodeToLocalCodePage(m_fileName, m_buffer, true); |
| |
| const char* const theTranscodedFileNamePointer = &*m_buffer.begin(); |
| |
| // Create a file and ensure it has a place to live |
| m_fileHandle = fopen(theTranscodedFileNamePointer, "w"); |
| if (m_fileHandle == 0) |
| { |
| // Couldn't create or find the directory for the file to live in, so bail |
| m_error = true; |
| m_ready = false; |
| fprintf(stderr, "XalanXMLFileReporter.initialize() ERROR: unble to open file, %s", theTranscodedFileNamePointer); |
| return(false); |
| } |
| else |
| { |
| m_ready = true; |
| |
| initStrings(); |
| |
| startResultsFile(); |
| |
| // fprintf(stderr, "DEBUG:XalanXMLFileReporter.initialize() complete with " + fileName); |
| } |
| } |
| |
| return m_ready; |
| } |
| |
| |
| |
| bool |
| XalanXMLFileReporter::getFlushOnCaseClose() |
| { |
| return(m_flushOnCaseClose); |
| } |
| |
| |
| |
| const XalanDOMString& |
| XalanXMLFileReporter::getFileName() const |
| { |
| return(m_fileName); |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::setFileName(const XalanDOMString& fileName) |
| { |
| m_fileName = fileName; |
| } |
| |
| |
| |
| bool |
| XalanXMLFileReporter::checkError() |
| { |
| // Ensure our underlying reporter, if one, is still OK |
| if (m_fileHandle == 0) |
| { |
| m_error = true; |
| } |
| return(m_error); |
| } |
| |
| |
| |
| bool |
| XalanXMLFileReporter::isReady() |
| { |
| // Ensure our underlying reporter, if one, is still OK |
| if (m_fileHandle == 0) |
| { |
| // NEEDSWORK: should we set m_ready = false in this case? |
| // errors in the PrintStream are not necessarily fatal |
| m_error = true; |
| m_ready = false; |
| } |
| return(m_ready); |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::flush() |
| { |
| if (isReady()) |
| { |
| fflush(m_fileHandle); |
| } |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::close() |
| { |
| fflush(m_fileHandle); |
| if (isReady()) |
| { |
| if (m_fileHandle != 0) |
| { |
| closeResultsFile(); |
| fclose(m_fileHandle); |
| } |
| } |
| m_ready = false; |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::logTestFileInit(const XalanDOMString& msg) |
| { |
| XalanDOMString b(getMemoryManager()); |
| if (isReady()) |
| { |
| 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); |
| } |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::logTestFileClose(const XalanDOMString& /* msg */, const XalanDOMString& /* result */) |
| { |
| if (isReady()) |
| { |
| XalanDOMString b(getMemoryManager()); |
| b +=LESS_THAN_SOLIDUS; |
| b +=ELEM_TESTFILE; |
| b +=GREATER_THAN; |
| |
| printToFile(b); |
| } |
| flush(); |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::logTestCaseInit(const XalanDOMString& msg) |
| { |
| if (isReady()) |
| { |
| XalanDOMString b(getMemoryManager()); |
| XalanDOMString buffer(getMemoryManager()); |
| |
| b +=TESTCASEINIT_HDR; |
| b +=escapestring(msg, buffer); |
| b +=QUOTE_GREATER_THAN; |
| |
| printToFile(b); |
| } |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::logTestCaseClose(const XalanDOMString& /* msg */, const XalanDOMString& /* result */) |
| { |
| if (isReady()) |
| { |
| XalanDOMString b(getMemoryManager()); |
| b +=LESS_THAN_SOLIDUS; |
| b +=ELEM_TESTCASE; |
| b +=GREATER_THAN; |
| |
| printToFile(b); |
| } |
| if (getFlushOnCaseClose()) |
| { |
| flush(); |
| } |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::logMessage(int level, const XalanDOMString& msg) |
| { |
| char tmp[20]; |
| sprintf(tmp, "%d", level); |
| |
| if (isReady()) |
| { |
| 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(const char* desc, double theMetric, Hashtable& attrs) |
| { |
| XalanDOMString temp(getMemoryManager()); |
| |
| NumberToDOMString(theMetric, temp); |
| |
| attrs.insert(XalanDOMString(desc,getMemoryManager()) ,temp); |
| |
| } |
| |
| void |
| XalanXMLFileReporter::logElementWAttrs(int /* level */, const XalanDOMString& element, Hashtable& attrs, const XalanDOMString& msg) |
| { |
| if (isReady() && !element.empty()&& !attrs.empty()) |
| { |
| |
| 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) |
| { |
| b.erase(); |
| b +=(*i).first; |
| b +=EQUALS_QUOTE; |
| b +=(*i).second ; |
| b +=QUOTE; |
| printToFile(b); |
| } |
| |
| printToFile(GREATER_THAN); |
| if (msg.empty() != 0) |
| { |
| XalanDOMString theResult( getMemoryManager()); |
| printToFile(escapestring(msg,theResult )); |
| } |
| b.erase(); |
| b +=LESS_THAN_SOLIDUS; |
| b +=element; |
| b +=GREATER_THAN; |
| printToFile(b); |
| } |
| } |
| |
| void |
| XalanXMLFileReporter::logElement(const XalanDOMString& element, const XalanDOMString& msg) |
| { |
| if (isReady() && !element.empty() && !msg.empty()) |
| { |
| 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); |
| } |
| } |
| |
| void |
| XalanXMLFileReporter::logStatistic (int level, long lVal, double dVal, const XalanDOMString& msg) |
| { |
| if (isReady()) |
| { |
| XalanDOMString b(getMemoryManager()); |
| XalanDOMString buffer(getMemoryManager()); |
| char tmp[40]; |
| |
| sprintf(tmp, "%d", level); |
| 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); |
| |
| 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); |
| |
| 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); |
| |
| } |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::logArbitraryMessage (int level, const XalanDOMString& msg) |
| { |
| char tmp[20]; |
| sprintf(tmp, "%d", level); |
| |
| if (isReady()) |
| { |
| 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); |
| } |
| } |
| |
| /* |
| void logHashtable (int level, Hashtable hash, XalanDOMString msg) |
| { |
| if (isReady()) |
| { |
| printToFile(HASHTABLE_HDR + level + QUOTE_SPACE + ATTR_DESC + EQUALS_QUOTE + msg + QUOTE_GREATER_THAN); |
| if (hash == null) |
| { |
| printToFile(LESS_THAN + ELEM_HASHITEM + SPACE + ATTR_KEY + "=\"null\">"); |
| printToFile(LESS_THAN_SOLIDUS + ELEM_HASHITEM + GREATER_THAN); |
| } |
| try |
| { |
| for (Enumeration enum = hash.keys(); enum.hasMoreElements();) |
| { |
| Object key = enum.nextElement(); |
| // Ensure we'll have clean output by pre-fetching value before outputting anything |
| XalanDOMString value = hash.get(key).tostring(); |
| printToFile(HASHITEM_HDR + key.tostring() + QUOTE_GREATER_THAN); |
| printToFile(value); |
| printToFile(LESS_THAN_SOLIDUS + ELEM_HASHITEM + GREATER_THAN); |
| } |
| } |
| catch (Exception e) |
| { |
| // No-op: should ensure we have clean output |
| } |
| printToFile(LESS_THAN_SOLIDUS + ELEM_HASHTABLE + GREATER_THAN); |
| } |
| } |
| */ |
| |
| |
| |
| void |
| XalanXMLFileReporter::logCheckPass(const XalanDOMString& comment) |
| { |
| if (isReady()) |
| { |
| XalanDOMString b(getMemoryManager()); |
| XalanDOMString buffer(getMemoryManager()); |
| b += CHECKPASS_HDR; |
| b += escapestring(comment,buffer); |
| b +=QUOTE_SOLIDUS_GREATER_THAN; |
| |
| printToFile(b); |
| } |
| } |
| |
| |
| void |
| XalanXMLFileReporter::logCheckFail(const XalanDOMString& comment) |
| { |
| if (isReady()) |
| { |
| 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, const Hashtable& actexp) |
| { |
| if (isReady()) |
| { |
| XalanDOMString b(getMemoryManager()); |
| XalanDOMString buffer(getMemoryManager()); |
| |
| b+= CHECKFAIL_HDR; |
| b+= escapestring(test, buffer); |
| b+= QUOTE; |
| |
| printToFile(b); |
| |
| printToFile(GREATER_THAN); |
| |
| Hashtable::const_iterator aeEnd = actexp.end(); |
| for(Hashtable::const_iterator ii = actexp.begin(); ii != aeEnd; ++ii) |
| { |
| logElement((*ii).first, (*ii).second); |
| } |
| |
| printToFile(CHECKFAIL_FTR); |
| } |
| } |
| |
| void |
| XalanXMLFileReporter::logCheckFail(const XalanDOMString& test, const Hashtable& attrs, const Hashtable& actexp) |
| { |
| if (isReady()) |
| { |
| 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::const_iterator aeEnd = actexp.end(); |
| for(Hashtable::const_iterator ii = actexp.begin(); ii != aeEnd; ++ii) |
| { |
| logElement((*ii).first, (*ii).second); |
| } |
| |
| printToFile(CHECKFAIL_FTR); |
| } |
| } |
| |
| void |
| XalanXMLFileReporter::logCheckAmbiguous(const XalanDOMString& comment) |
| { |
| if (isReady()) |
| { |
| XalanDOMString b(getMemoryManager()); |
| XalanDOMString buffer(getMemoryManager()); |
| |
| b += CHECKAMBG_HDR; |
| b += escapestring(comment, buffer); |
| b += QUOTE_SOLIDUS_GREATER_THAN; |
| |
| printToFile(b); |
| } |
| } |
| |
| |
| void |
| XalanXMLFileReporter::logErrorResult(const XalanDOMString& test, const XalanDOMString& reason) |
| { |
| if (isReady()) |
| { |
| 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); |
| |
| } |
| } |
| |
| |
| void |
| XalanXMLFileReporter::logCheckErr(const XalanDOMString& comment) |
| { |
| if (isReady()) |
| { |
| XalanDOMString b(getMemoryManager()); |
| XalanDOMString buffer(getMemoryManager()); |
| |
| b += CHECKERRR_HDR; |
| b += escapestring(comment, buffer); |
| b += QUOTE_SOLIDUS_GREATER_THAN; |
| printToFile(b); |
| } |
| } |
| |
| |
| |
| static const XalanDOMChar theAmpersandString[] = |
| { |
| XalanUnicode::charAmpersand, |
| XalanUnicode::charLetter_a, |
| XalanUnicode::charLetter_m, |
| XalanUnicode::charLetter_p, |
| XalanUnicode::charSemicolon, |
| 0 |
| }; |
| |
| |
| |
| static const XalanDOMChar theApostropheString[] = |
| { |
| XalanUnicode::charAmpersand, |
| XalanUnicode::charLetter_a, |
| XalanUnicode::charLetter_p, |
| XalanUnicode::charLetter_o, |
| XalanUnicode::charLetter_s, |
| XalanUnicode::charSemicolon, |
| 0 |
| }; |
| |
| |
| |
| static const XalanDOMChar theLessThanString[] = |
| { |
| XalanUnicode::charAmpersand, |
| XalanUnicode::charLetter_l, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charSemicolon, |
| 0 |
| }; |
| |
| |
| |
| static const XalanDOMChar theGreaterThanString[] = |
| { |
| XalanUnicode::charAmpersand, |
| XalanUnicode::charLetter_g, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charSemicolon, |
| 0 |
| }; |
| |
| |
| |
| static const XalanDOMChar theQuoteString[] = |
| { |
| XalanUnicode::charAmpersand, |
| XalanUnicode::charLetter_q, |
| XalanUnicode::charLetter_u, |
| XalanUnicode::charLetter_o, |
| XalanUnicode::charLetter_t, |
| XalanUnicode::charSemicolon, |
| 0 |
| }; |
| |
| |
| |
| XalanDOMString& |
| XalanXMLFileReporter::escapestring(const XalanDOMString& s, XalanDOMString& sb) |
| { |
| |
| const XalanDOMString::size_type length = s.length(); |
| |
| sb.reserve(length); |
| |
| for (XalanDOMString::size_type i = 0; i < length; i++) |
| { |
| const XalanDOMChar ch = s[i]; |
| |
| if (XalanUnicode::charLessThanSign == ch) |
| { |
| sb.append(theLessThanString); |
| } |
| else if (XalanUnicode::charGreaterThanSign == ch) |
| { |
| sb.append(theGreaterThanString); |
| } |
| else if (XalanUnicode::charAmpersand == ch) |
| { |
| sb.append(theAmpersandString); |
| } |
| else if (XalanUnicode::charQuoteMark == ch) |
| { |
| sb.append(theQuoteString); |
| } |
| else if (XalanUnicode::charApostrophe == ch) |
| { |
| sb.append(theApostropheString); |
| } |
| else |
| { |
| sb.append(1, ch); |
| } |
| } |
| |
| return sb; |
| } |
| |
| |
| |
| bool |
| XalanXMLFileReporter::startResultsFile() |
| { |
| if (isReady()) |
| { |
| // Write out XML header and root test result element |
| printToFile(XML_HEADER); |
| |
| // Note: this tag is closed in our .close() method, which the caller had better call! |
| |
| 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; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| |
| |
| bool |
| XalanXMLFileReporter::closeResultsFile() |
| { |
| if (isReady() == false) |
| { |
| return false; |
| } |
| else |
| { |
| XalanDOMString b(getMemoryManager()); |
| b += LESS_THAN_SOLIDUS; |
| b += ELEM_RESULTSFILE; |
| b += GREATER_THAN; |
| |
| printToFile(b); |
| return true; |
| } |
| } |
| |
| |
| bool |
| XalanXMLFileReporter::printToFile(const XalanDOMString& output) |
| { |
| const XalanDOMString::size_type theLength = |
| output.size(); |
| |
| if (isReady() == false) |
| { |
| return false; |
| } |
| else if (theLength == 0) |
| { |
| return true; |
| } |
| else |
| { |
| m_buffer.resize((theLength * 4) + 1); |
| |
| typedef XalanOutputTranscoder::size_type size_type; |
| typedef XalanOutputTranscoder::XalanXMLByte XalanXMLByte; |
| |
| XalanOutputTranscoder::size_type theCharsTranscoded; |
| XalanOutputTranscoder::size_type theTargetBytesUsed; |
| |
| const XalanOutputTranscoder::eCode theCode = |
| m_transcoder->transcode( |
| output.c_str(), |
| theLength, |
| reinterpret_cast<XalanXMLByte*>(&*m_buffer.begin()), |
| m_buffer.size(), |
| theCharsTranscoded, |
| theTargetBytesUsed); |
| |
| if (theCode != XalanTranscodingServices::OK || |
| theCharsTranscoded != theLength) |
| { |
| fputs("Error transcoding text.", m_fileHandle); |
| } |
| else |
| { |
| m_buffer[theTargetBytesUsed] = 0; |
| |
| fputs(&*m_buffer.begin(), m_fileHandle); |
| } |
| |
| fputs("\n", m_fileHandle); |
| |
| return true; |
| } |
| } |
| |
| |
| |
| XalanDOMString & |
| XalanXMLFileReporter::getDateTimeString(XalanDOMString& theResult) |
| { |
| struct tm *tmNow; |
| time_t time_tNow; |
| |
| time(&time_tNow); |
| tmNow = localtime(&time_tNow); |
| |
| const char* const theTime = asctime(tmNow); |
| |
| theResult.assign(theTime, XalanDOMString::length(theTime) - 1); |
| |
| return theResult; |
| } |
| |
| |
| |
| void |
| XalanXMLFileReporter::initStrings() |
| { |
| 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 = 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; |
| |
| } |
| |
| |
| |
| } |