catch2/include/internal/catch_xmlwriter.hpp

317 lines
9.8 KiB
C++
Raw Normal View History

2010-12-10 09:01:42 +01:00
/*
* Created by Phil on 09/12/2010.
* Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
#include "catch_stream.h"
#include "catch_compiler_capabilities.h"
#include "catch_suppress_warnings.h"
2014-10-02 20:13:21 +02:00
#include <sstream>
#include <string>
#include <vector>
#include <iomanip>
#include <cassert>
2012-05-15 09:02:36 +02:00
namespace Catch {
// (see: https://en.wikipedia.org/wiki/UTF-8#Codepage_layout)
namespace Utf8 {
inline bool isSingleByteChar(unsigned char b) {
// Plain ASCII chars
return b <= 0x7F;
}
inline bool isFollowByteInMultiByteChar(unsigned char b) {
return b >= 0x80 && b <= 0xBF;
}
inline bool isFirstInTwoByteChar(unsigned char b) {
return b >= 0xC2 && b <= 0xDF;
}
inline bool isFirstInThreeByteChar(unsigned char b) {
return b >= 0xE0 && b <= 0xEF;
}
inline bool isFirstInFourByteChar(unsigned char b) {
return b >= 0xF0 && b <= 0xF4;
}
inline bool isInvalidChar(unsigned char b) {
return b == 0xC0 || b == 0xC1 || b >= 0xF5;
}
inline bool isValid(const char* str, size_t len) {
int outstandingBytesOfCurrentChar = 0;
for( std::size_t i = 0; i < len; ++ i ) {
unsigned char b = static_cast<unsigned char>( str[i] );
switch( outstandingBytesOfCurrentChar )
{
case 0:
if( isSingleByteChar( b ) )
outstandingBytesOfCurrentChar = 0;
else if( isFirstInTwoByteChar( b ) )
outstandingBytesOfCurrentChar = 1;
else if( isFirstInThreeByteChar( b ) )
outstandingBytesOfCurrentChar = 2;
else if( isFirstInFourByteChar( b ) )
outstandingBytesOfCurrentChar = 3;
else
return false;
break;
case 1:
case 2:
case 3:
if( !isFollowByteInMultiByteChar( b ) )
return false;
outstandingBytesOfCurrentChar--;
break;
default:
// outstandingBytesOfCurrentChar is negative: got follow byte when start byte was expected
return false;
}
// explicit negative check (sould be fully redundant here)
assert( isInvalidChar( b ) == false );
}
return outstandingBytesOfCurrentChar == 0;
}
inline bool isValid(const std::string& str) {
return isValid(str.c_str(), str.size());
}
}
2012-05-15 09:02:36 +02:00
class XmlEncode {
public:
enum ForWhat { ForTextNodes, ForAttributes };
XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes )
: m_str( str ),
m_forWhat( forWhat )
{}
void encodeTo( std::ostream& os ) const {
// Apostrophe escaping not necessary if we always use " to write attributes
// (see: http://www.w3.org/TR/xml/#syntax)
// Preserve utf8 as it is the default on most platforms and in xml
bool isValidUtf8 = Utf8::isValid( m_str );
for( std::size_t i = 0; i < m_str.size(); ++ i ) {
unsigned char c = static_cast<unsigned char>( m_str[i] );
switch( c ) {
case '<': os << "&lt;"; break;
case '&': os << "&amp;"; break;
case '>':
// See: http://www.w3.org/TR/xml/#syntax
if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' )
os << "&gt;";
else
os << c;
break;
case '\"':
if( m_forWhat == ForAttributes )
os << "&quot;";
else
os << c;
break;
default:
// Escape control chars - based on contribution by @espenalb in PR #465
if ( ( c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c == '\x7F' || (c > '\x7F' && !isValidUtf8) )
os << "&#x" << std::uppercase << std::hex << static_cast<int>( c ) << ';';
else
os << c;
}
}
}
friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
xmlEncode.encodeTo( os );
return os;
}
private:
std::string m_str;
ForWhat m_forWhat;
};
2012-05-15 09:02:36 +02:00
class XmlWriter {
2010-12-10 09:01:42 +01:00
public:
2012-05-15 09:02:36 +02:00
class ScopedElement {
2010-12-10 09:01:42 +01:00
public:
2012-05-15 09:02:36 +02:00
ScopedElement( XmlWriter* writer )
2010-12-10 09:01:42 +01:00
: m_writer( writer )
2012-05-15 09:02:36 +02:00
{}
ScopedElement( ScopedElement const& other )
2012-05-15 09:02:36 +02:00
: m_writer( other.m_writer ){
other.m_writer = CATCH_NULL;
2010-12-10 09:01:42 +01:00
}
2012-05-15 09:02:36 +02:00
~ScopedElement() {
2010-12-10 09:01:42 +01:00
if( m_writer )
m_writer->endElement();
}
ScopedElement& writeText( std::string const& text, bool indent = true ) {
m_writer->writeText( text, indent );
2010-12-10 09:01:42 +01:00
return *this;
}
template<typename T>
ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
m_writer->writeAttribute( name, attribute );
return *this;
}
2010-12-10 09:01:42 +01:00
private:
mutable XmlWriter* m_writer;
};
2012-05-15 09:02:36 +02:00
XmlWriter()
: m_tagIsOpen( false ),
m_needsNewline( false ),
m_os( &Catch::cout() )
2012-05-15 09:02:36 +02:00
{}
2012-05-15 09:02:36 +02:00
XmlWriter( std::ostream& os )
2010-12-10 09:01:42 +01:00
: m_tagIsOpen( false ),
m_needsNewline( false ),
m_os( &os )
2012-05-15 09:02:36 +02:00
{}
2012-05-15 09:02:36 +02:00
~XmlWriter() {
2010-12-10 09:01:42 +01:00
while( !m_tags.empty() )
endElement();
}
XmlWriter& startElement( std::string const& name ) {
2010-12-10 09:01:42 +01:00
ensureTagClosed();
newlineIfNecessary();
stream() << m_indent << "<" << name;
2010-12-10 09:01:42 +01:00
m_tags.push_back( name );
m_indent += " ";
m_tagIsOpen = true;
return *this;
}
ScopedElement scopedElement( std::string const& name ) {
2010-12-10 09:01:42 +01:00
ScopedElement scoped( this );
startElement( name );
return scoped;
}
2012-05-15 09:02:36 +02:00
XmlWriter& endElement() {
2010-12-10 09:01:42 +01:00
newlineIfNecessary();
m_indent = m_indent.substr( 0, m_indent.size()-2 );
2012-05-15 09:02:36 +02:00
if( m_tagIsOpen ) {
stream() << "/>\n";
2010-12-10 09:01:42 +01:00
m_tagIsOpen = false;
}
2012-05-15 09:02:36 +02:00
else {
stream() << m_indent << "</" << m_tags.back() << ">\n";
}
2010-12-10 09:01:42 +01:00
m_tags.pop_back();
return *this;
}
XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
if( !name.empty() && !attribute.empty() )
stream() << " " << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << "\"";
2010-12-10 09:01:42 +01:00
return *this;
}
XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
return *this;
}
template<typename T>
XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
}
XmlWriter& writeText( std::string const& text, bool indent = true ) {
2012-05-15 09:02:36 +02:00
if( !text.empty() ){
2010-12-10 09:01:42 +01:00
bool tagWasOpen = m_tagIsOpen;
ensureTagClosed();
if( tagWasOpen && indent )
stream() << m_indent;
stream() << XmlEncode( text );
2010-12-10 09:01:42 +01:00
m_needsNewline = true;
}
return *this;
}
XmlWriter& writeComment( std::string const& text ) {
2010-12-10 09:01:42 +01:00
ensureTagClosed();
stream() << m_indent << "<!--" << text << "-->";
2010-12-10 09:01:42 +01:00
m_needsNewline = true;
return *this;
}
2012-05-15 09:02:36 +02:00
XmlWriter& writeBlankLine() {
2010-12-10 09:01:42 +01:00
ensureTagClosed();
stream() << "\n";
2010-12-10 09:01:42 +01:00
return *this;
}
2014-05-19 19:57:14 +02:00
void setStream( std::ostream& os ) {
m_os = &os;
}
2010-12-10 09:01:42 +01:00
private:
2014-05-19 19:57:14 +02:00
XmlWriter( XmlWriter const& );
void operator=( XmlWriter const& );
2012-05-15 09:02:36 +02:00
std::ostream& stream() {
return *m_os;
}
2012-05-15 09:02:36 +02:00
void ensureTagClosed() {
if( m_tagIsOpen ) {
stream() << ">\n";
2010-12-10 09:01:42 +01:00
m_tagIsOpen = false;
}
}
2012-05-15 09:02:36 +02:00
void newlineIfNecessary() {
if( m_needsNewline ) {
stream() << "\n";
2010-12-10 09:01:42 +01:00
m_needsNewline = false;
}
}
2010-12-10 09:01:42 +01:00
bool m_tagIsOpen;
bool m_needsNewline;
std::vector<std::string> m_tags;
std::string m_indent;
std::ostream* m_os;
2010-12-10 09:01:42 +01:00
};
2010-12-10 09:01:42 +01:00
}
#include "catch_reenable_warnings.h"
#endif // TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED