Revert "XmlWriter reverts to XML 1.0."

This reverts commit a189387f49.
2025-10-31 12:17:11 +01:00 · 2017-02-06 16:21:01 +00:00
parent 23eb4cc580
commit 88b760276d
6 changed files with 52 additions and 121 deletions
--- a/include/internal/catch_xmlwriter.hpp
+++ b/include/internal/catch_xmlwriter.hpp
@@ -22,12 +22,10 @@ namespace Catch {
    class XmlEncode {
    public:
        enum ForWhat { ForTextNodes, ForAttributes };
-        enum XmlVersion { _1_0, _1_1 };

-        XmlEncode( XmlVersion xmlVersion, std::string const& str, ForWhat forWhat = ForTextNodes )
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes )
        :   m_str( str ),
-            m_forWhat( forWhat ),
-            m_xmlVersion( xmlVersion )
+            m_forWhat( forWhat )
        {}

        void encodeTo( std::ostream& os ) const {
@@ -59,15 +57,8 @@ namespace Catch {
                    default:
                        // Escape control chars - based on contribution by @espenalb in PR #465 and
                        // by @mrpi PR #588
-                        if ( ( c >= 0 && c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' ) {
-                            if( m_xmlVersion == _1_0 )
-                                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                                os << "\\x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-                                   << static_cast<int>( c );
-                            else
-                                os << "&#x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-                                   << static_cast<int>( c ) << ';';
-                        }
+                        if ( ( c >= 0 && c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' )
+                            os << "&#x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2) << static_cast<int>( c ) << ';';
                        else
                            os << c;
                }
@@ -82,7 +73,6 @@ namespace Catch {
    private:
        std::string m_str;
        ForWhat m_forWhat;
-        XmlVersion m_xmlVersion;
    };

    class XmlWriter {
@@ -122,19 +112,20 @@ namespace Catch {
        XmlWriter()
        :   m_tagIsOpen( false ),
            m_needsNewline( false ),
-            m_os( Catch::cout() ),
-            m_xmlVersion( XmlEncode::_1_0 )
+            m_os( &Catch::cout() )
        {
-            writeDeclaration();
+            // We encode control characters, which requires
+            // XML 1.1
+            // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+            *m_os << "<?xml version=\"1.1\" encoding=\"UTF-8\"?>\n";
        }

        XmlWriter( std::ostream& os )
        :   m_tagIsOpen( false ),
            m_needsNewline( false ),
-            m_os( os ),
-            m_xmlVersion( XmlEncode::_1_0 )
+            m_os( &os )
        {
-            writeDeclaration();
+            *m_os << "<?xml version=\"1.1\" encoding=\"UTF-8\"?>\n";
        }

        ~XmlWriter() {
@@ -145,7 +136,7 @@ namespace Catch {
        XmlWriter& startElement( std::string const& name ) {
            ensureTagClosed();
            newlineIfNecessary();
-            m_os << m_indent << '<' << name;
+            stream() << m_indent << '<' << name;
            m_tags.push_back( name );
            m_indent += "  ";
            m_tagIsOpen = true;
@@ -162,11 +153,11 @@ namespace Catch {
            newlineIfNecessary();
            m_indent = m_indent.substr( 0, m_indent.size()-2 );
            if( m_tagIsOpen ) {
-                m_os << "/>\n";
+                stream() << "/>\n";
                m_tagIsOpen = false;
            }
            else {
-                m_os << m_indent << "</" << m_tags.back() << ">\n";
+                stream() << m_indent << "</" << m_tags.back() << ">\n";
            }
            m_tags.pop_back();
            return *this;
@@ -174,12 +165,12 @@ namespace Catch {

        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
            if( !name.empty() && !attribute.empty() )
-                m_os << ' ' << name << "=\"" << XmlEncode( m_xmlVersion, attribute, XmlEncode::ForAttributes ) << '"';
+                stream() << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
            return *this;
        }

        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
-            m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+            stream() << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
            return *this;
        }

@@ -195,8 +186,8 @@ namespace Catch {
                bool tagWasOpen = m_tagIsOpen;
                ensureTagClosed();
                if( tagWasOpen && indent )
-                    m_os << m_indent;
-                m_os << XmlEncode( m_xmlVersion, text );
+                    stream() << m_indent;
+                stream() << XmlEncode( text );
                m_needsNewline = true;
            }
            return *this;
@@ -204,42 +195,39 @@ namespace Catch {

        XmlWriter& writeComment( std::string const& text ) {
            ensureTagClosed();
-            m_os << m_indent << "<!--" << text << "-->";
+            stream() << m_indent << "<!--" << text << "-->";
            m_needsNewline = true;
            return *this;
        }

        XmlWriter& writeBlankLine() {
            ensureTagClosed();
-            m_os << '\n';
+            stream() << '\n';
            return *this;
        }

+        void setStream( std::ostream& os ) {
+            m_os = &os;
+        }
+
    private:
        XmlWriter( XmlWriter const& );
        void operator=( XmlWriter const& );

-        void writeDeclaration() {
-            switch( m_xmlVersion ) {
-                case XmlEncode::_1_0:
-                    m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-                    break;
-                case XmlEncode::_1_1:
-                    m_os << "<?xml version=\"1.1\" encoding=\"UTF-8\"?>\n";
-                    break;
-            }
+        std::ostream& stream() {
+            return *m_os;
        }

        void ensureTagClosed() {
            if( m_tagIsOpen ) {
-                m_os << ">\n";
+                stream() << ">\n";
                m_tagIsOpen = false;
            }
        }

        void newlineIfNecessary() {
            if( m_needsNewline ) {
-                m_os << '\n';
+                stream() << '\n';
                m_needsNewline = false;
            }
        }
@@ -248,8 +236,7 @@ namespace Catch {
        bool m_needsNewline;
        std::vector<std::string> m_tags;
        std::string m_indent;
-        std::ostream& m_os;
-        XmlEncode::XmlVersion m_xmlVersion;
+        std::ostream* m_os;
    };

 }
--- a/projects/SelfTest/Baselines/console.std.approved.txt
+++ b/projects/SelfTest/Baselines/console.std.approved.txt
@@ -830,5 +830,5 @@ with expansion:

 ===============================================================================
 test cases: 157 | 113 passed | 42 failed |  2 failed as expected
-assertions: 915 | 819 passed | 78 failed | 18 failed as expected
+assertions: 913 | 817 passed | 78 failed | 18 failed as expected

--- a/projects/SelfTest/Baselines/console.sw.approved.txt
+++ b/projects/SelfTest/Baselines/console.sw.approved.txt
@@ -7982,53 +7982,27 @@ with expansion:

 -------------------------------------------------------------------------------
 XmlEncode
-  string with control char (1) (XML 1.0)
+  string with control char (1)
 -------------------------------------------------------------------------------
 MiscTests.cpp:<line number>
 ...............................................................................

 MiscTests.cpp:<line number>:
 PASSED:
-  REQUIRE( encode( "[\x01]" ) == "[\\x01]" )
-with expansion:
-  "[\x01]" == "[\x01]"
-
-------------------------------------------------------------------------------
-XmlEncode
-  string with control char (1) (XMl 1.1)
-------------------------------------------------------------------------------
-MiscTests.cpp:<line number>
-...............................................................................
-
-MiscTests.cpp:<line number>:
-PASSED:
-  REQUIRE( encode( "[\x01]", Catch::XmlEncode::ForTextNodes, Catch::XmlEncode::_1_1 ) == "[&#x01;]" )
+  REQUIRE( encode( "[\x01]" ) == "[&#x01;]" )
 with expansion:
  "[&#x01;]" == "[&#x01;]"

 -------------------------------------------------------------------------------
 XmlEncode
-  string with control char (x7F) (XML 1.0)
+  string with control char (x7F)
 -------------------------------------------------------------------------------
 MiscTests.cpp:<line number>
 ...............................................................................

 MiscTests.cpp:<line number>:
 PASSED:
-  REQUIRE( encode( "[\x7F]" ) == "[\\x7F]" )
-with expansion:
-  "[\x7F]" == "[\x7F]"
-
-------------------------------------------------------------------------------
-XmlEncode
-  string with control char (x7F) (XML 1.1)
-------------------------------------------------------------------------------
-MiscTests.cpp:<line number>
-...............................................................................
-
-MiscTests.cpp:<line number>:
-PASSED:
-  REQUIRE( encode( "[\x7F]", Catch::XmlEncode::ForTextNodes, Catch::XmlEncode::_1_1 ) == "[&#x7F;]" )
+  REQUIRE( encode( "[\x7F]" ) == "[&#x7F;]" )
 with expansion:
  "[&#x7F;]" == "[&#x7F;]"

@@ -9052,5 +9026,5 @@ PASSED:

 ===============================================================================
 test cases: 157 | 112 passed | 43 failed |  2 failed as expected
-assertions: 917 | 819 passed | 80 failed | 18 failed as expected
+assertions: 915 | 817 passed | 80 failed | 18 failed as expected

--- a/projects/SelfTest/Baselines/junit.sw.approved.txt
+++ b/projects/SelfTest/Baselines/junit.sw.approved.txt
@@ -1,6 +1,6 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.1" encoding="UTF-8"?>
 <testsuites>
-  <testsuite name="<exe-name>" errors="13" failures="68" tests="918" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="13" failures="68" tests="916" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
    <testcase classname="global" name="# A test name that starts with a #" time="{duration}"/>
    <testcase classname="global" name="'Not' checks that should fail" time="{duration}">
      <failure message="false != false" type="CHECK">
@@ -538,10 +538,8 @@ ExceptionTests.cpp:<line number>
    <testcase classname="XmlEncode" name="string with less-than" time="{duration}"/>
    <testcase classname="XmlEncode" name="string with greater-than" time="{duration}"/>
    <testcase classname="XmlEncode" name="string with quotes" time="{duration}"/>
-    <testcase classname="XmlEncode" name="string with control char (1) (XML 1.0)" time="{duration}"/>
-    <testcase classname="XmlEncode" name="string with control char (1) (XMl 1.1)" time="{duration}"/>
-    <testcase classname="XmlEncode" name="string with control char (x7F) (XML 1.0)" time="{duration}"/>
-    <testcase classname="XmlEncode" name="string with control char (x7F) (XML 1.1)" time="{duration}"/>
+    <testcase classname="XmlEncode" name="string with control char (1)" time="{duration}"/>
+    <testcase classname="XmlEncode" name="string with control char (x7F)" time="{duration}"/>
    <testcase classname="global" name="atomic if" time="{duration}"/>
    <testcase classname="global" name="boolean member" time="{duration}"/>
    <testcase classname="global" name="checkedElse" time="{duration}"/>
--- a/projects/SelfTest/Baselines/xml.sw.approved.txt
+++ b/projects/SelfTest/Baselines/xml.sw.approved.txt
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.1" encoding="UTF-8"?>
 <Catch name="<exe-name>">
  <Group name="<exe-name>">
    <TestCase name="# A test name that starts with a #">
@@ -8462,21 +8462,10 @@ there"
        </Expression>
        <OverallResults successes="2" failures="0" expectedFailures="0"/>
      </Section>
-      <Section name="string with control char (1) (XML 1.0)">
+      <Section name="string with control char (1)">
        <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/MiscTests.cpp" >
          <Original>
-            encode( "[\x01]" ) == "[\\x01]"
-          </Original>
-          <Expanded>
-            "[\x01]" == "[\x01]"
-          </Expanded>
-        </Expression>
-        <OverallResults successes="1" failures="0" expectedFailures="0"/>
-      </Section>
-      <Section name="string with control char (1) (XMl 1.1)">
-        <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/MiscTests.cpp" >
-          <Original>
-            encode( "[\x01]", Catch::XmlEncode::ForTextNodes, Catch::XmlEncode::_1_1 ) == "[&amp;#x01;]"
+            encode( "[\x01]" ) == "[&amp;#x01;]"
          </Original>
          <Expanded>
            "[&amp;#x01;]" == "[&amp;#x01;]"
@@ -8484,21 +8473,10 @@ there"
        </Expression>
        <OverallResults successes="1" failures="0" expectedFailures="0"/>
      </Section>
-      <Section name="string with control char (x7F) (XML 1.0)">
+      <Section name="string with control char (x7F)">
        <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/MiscTests.cpp" >
          <Original>
-            encode( "[\x7F]" ) == "[\\x7F]"
-          </Original>
-          <Expanded>
-            "[\x7F]" == "[\x7F]"
-          </Expanded>
-        </Expression>
-        <OverallResults successes="1" failures="0" expectedFailures="0"/>
-      </Section>
-      <Section name="string with control char (x7F) (XML 1.1)">
-        <Expression success="true" type="REQUIRE" filename="projects/<exe-name>/MiscTests.cpp" >
-          <Original>
-            encode( "[\x7F]", Catch::XmlEncode::ForTextNodes, Catch::XmlEncode::_1_1 ) == "[&amp;#x7F;]"
+            encode( "[\x7F]" ) == "[&amp;#x7F;]"
          </Original>
          <Expanded>
            "[&amp;#x7F;]" == "[&amp;#x7F;]"
@@ -9542,7 +9520,7 @@ there"
      </Section>
      <OverallResult success="true"/>
    </TestCase>
-    <OverallResults successes="819" failures="81" expectedFailures="18"/>
+    <OverallResults successes="817" failures="81" expectedFailures="18"/>
  </Group>
-  <OverallResults successes="819" failures="80" expectedFailures="18"/>
+  <OverallResults successes="817" failures="80" expectedFailures="18"/>
 </Catch>
--- a/projects/SelfTest/MiscTests.cpp
+++ b/projects/SelfTest/MiscTests.cpp
@@ -429,9 +429,9 @@ TEST_CASE( "toString on wchar_t returns the string contents", "[toString]" ) {
        CHECK( result == "\"wide load\"" );
 }

-inline std::string encode( std::string const& str, Catch::XmlEncode::ForWhat forWhat = Catch::XmlEncode::ForTextNodes, Catch::XmlEncode::XmlVersion version = Catch::XmlEncode::_1_0 ) {
+inline std::string encode( std::string const& str, Catch::XmlEncode::ForWhat forWhat = Catch::XmlEncode::ForTextNodes ) {
    std::ostringstream oss;
-    oss << Catch::XmlEncode( version, str, forWhat );
+    oss << Catch::XmlEncode( str, forWhat );
    return oss.str();
 }

@@ -457,17 +457,11 @@ TEST_CASE( "XmlEncode" ) {
        REQUIRE( encode( stringWithQuotes ) == stringWithQuotes );
        REQUIRE( encode( stringWithQuotes, Catch::XmlEncode::ForAttributes ) == "don't &quot;quote&quot; me on that" );
    }
-    SECTION( "string with control char (1) (XML 1.0)" ) {
-        REQUIRE( encode( "[\x01]" ) == "[\\x01]" );
+    SECTION( "string with control char (1)" ) {
+        REQUIRE( encode( "[\x01]" ) == "[&#x01;]" );
    }
-    SECTION( "string with control char (1) (XMl 1.1)" ) {
-        REQUIRE( encode( "[\x01]", Catch::XmlEncode::ForTextNodes, Catch::XmlEncode::_1_1 ) == "[&#x01;]" );
-    }
-    SECTION( "string with control char (x7F) (XML 1.0)" ) {
-        REQUIRE( encode( "[\x7F]" ) == "[\\x7F]" );
-    }
-    SECTION( "string with control char (x7F) (XML 1.1)" ) {
-        REQUIRE( encode( "[\x7F]", Catch::XmlEncode::ForTextNodes, Catch::XmlEncode::_1_1 ) == "[&#x7F;]" );
+    SECTION( "string with control char (x7F)" ) {
+        REQUIRE( encode( "[\x7F]" ) == "[&#x7F;]" );
    }
 }