Progmasoft Git

catch3

Progmasoft Catch3: an independently maintained C++17 test framework with a parallel runner, property checks, snapshots and structured results.

Clonegit clone https://git.progmasoft.com/catch3

Extracted string matchers impl into cpp that is only compiled into main TU

Commit
1400127d6f5d481c380097d936df89d0020fc196
Author
Phil Nash ·
Parents
7fed25ad1fe4

Files · Download .tar.gz

Changes

 CMakeLists.txt                             |   1 +
 include/catch.hpp                          |   2 +-
 include/internal/catch_impl.hpp            |   1 +
 include/internal/catch_matchers_string.h   |  67 +++++++++++++
 include/internal/catch_matchers_string.hpp | 145 ++++++++++++-----------------
 5 files changed, 132 insertions(+), 84 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 76d33c33..b6fff3ca 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -154,6 +154,7 @@ set(INTERNAL_HEADERS
         ${HEADER_DIR}/internal/catch_legacy_reporter_adapter.hpp
         ${HEADER_DIR}/internal/catch_list.hpp
         ${HEADER_DIR}/internal/catch_matchers.hpp
+        ${HEADER_DIR}/internal/catch_matchers_string.h
         ${HEADER_DIR}/internal/catch_matchers_string.hpp
         ${HEADER_DIR}/internal/catch_message.h
         ${HEADER_DIR}/internal/catch_message.hpp
diff --git a/include/catch.hpp b/include/catch.hpp
index 552482bd..4bf81da3 100644
--- a/include/catch.hpp
+++ b/include/catch.hpp
@@ -36,7 +36,7 @@
 #include "internal/catch_generators.hpp"
 #include "internal/catch_interfaces_exception.h"
 #include "internal/catch_approx.hpp"
-#include "internal/catch_matchers_string.hpp"
+#include "internal/catch_matchers_string.h"
 #include "internal/catch_compiler_capabilities.h"
 #include "internal/catch_interfaces_tag_alias_registry.h"
 
diff --git a/include/internal/catch_impl.hpp b/include/internal/catch_impl.hpp
index 00101969..3886136e 100644
--- a/include/internal/catch_impl.hpp
+++ b/include/internal/catch_impl.hpp
@@ -36,6 +36,7 @@
 #include "catch_result_builder.hpp"
 #include "catch_tag_alias_registry.hpp"
 #include "catch_test_case_tracker.hpp"
+#include "catch_matchers_string.hpp"
 
 #include "../reporters/catch_reporter_multi.hpp"
 #include "../reporters/catch_reporter_xml.hpp"
diff --git a/include/internal/catch_matchers_string.h b/include/internal/catch_matchers_string.h
new file mode 100644
index 00000000..64c52993
--- /dev/null
+++ b/include/internal/catch_matchers_string.h
@@ -0,0 +1,67 @@
+/*
+ *  Created by Phil Nash on 08/02/2017.
+ *  Copyright (c) 2017 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_MATCHERS_STRING_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_MATCHERS_STRING_HPP_INCLUDED
+
+#include "catch_matchers.hpp"
+
+namespace Catch {
+namespace Matchers {
+
+    namespace StdString {
+
+        struct CasedString
+        {
+            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+            std::string adjustString( std::string const& str ) const;
+            std::string caseSensitivitySuffix() const;
+
+            CaseSensitive::Choice m_caseSensitivity;
+            std::string m_str;
+        };
+
+        struct StringMatcherBase : Impl::MatcherBase<std::string> {
+            StringMatcherBase( std::string operation, CasedString const& comparator );
+            virtual std::string toStringUncached() const CATCH_OVERRIDE;
+
+            CasedString m_comparator;
+            std::string m_operation;
+        };
+
+        struct EqualsMatcher : StringMatcherBase {
+            EqualsMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct ContainsMatcher : StringMatcherBase {
+            ContainsMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct StartsWithMatcher : StringMatcherBase {
+            StartsWithMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+        struct EndsWithMatcher : StringMatcherBase {
+            EndsWithMatcher( CasedString const& comparator );
+            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+        };
+
+    } // namespace StdString
+
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_MATCHERS_STRING_HPP_INCLUDED
diff --git a/include/internal/catch_matchers_string.hpp b/include/internal/catch_matchers_string.hpp
index 07ed4c17..edff6822 100644
--- a/include/internal/catch_matchers_string.hpp
+++ b/include/internal/catch_matchers_string.hpp
@@ -5,8 +5,6 @@
  * 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_MATCHERS_STRING_HPP_INCLUDED
-#define TWOBLUECUBES_CATCH_MATCHERS_STRING_HPP_INCLUDED
 
 #include "catch_matchers.hpp"
 
@@ -15,100 +13,81 @@ namespace Matchers {
 
     namespace StdString {
 
-        struct CasedString
-        {
-            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
-            :   m_caseSensitivity( caseSensitivity ),
-                m_str( adjustString( str ) )
-            {}
-            std::string adjustString( std::string const& str ) const {
-                return m_caseSensitivity == CaseSensitive::No
-                       ? toLower( str )
-                       : str;
-            }
-            std::string caseSensitivitySuffix() const {
-                return m_caseSensitivity == CaseSensitive::No
-                       ? " (case insensitive)"
-                       : std::string();
-            }
-            CaseSensitive::Choice m_caseSensitivity;
-            std::string m_str;
-        };
-
-        // !TBD Move impl
-        struct StringMatcherBase : Impl::MatcherBase<std::string> {
-            StringMatcherBase( std::string operation, CasedString const& comparator )
-            : m_comparator( comparator ),
-              m_operation( operation ) {
-            }
-
-            virtual std::string toStringUncached() const CATCH_OVERRIDE {
-                std::string description;
-                description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
-                                            m_comparator.caseSensitivitySuffix().size());
-                description += m_operation;
-                description += ": \"";
-                description += m_comparator.m_str;
-                description += "\"";
-                description += m_comparator.caseSensitivitySuffix();
-                return description;
-            }
-
-            CasedString m_comparator;
-            std::string m_operation;
-        };
-
-        // !TBD Move impl
-        struct EqualsMatcher : StringMatcherBase {
-            EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
-
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE {
-                return m_comparator.adjustString( source ) == m_comparator.m_str;
-            }
-        };
-        struct ContainsMatcher : StringMatcherBase {
-            ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
-
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE {
-                return contains( m_comparator.adjustString( source ), m_comparator.m_str );
-            }
-        };
-        struct StartsWithMatcher : StringMatcherBase {
-            StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
-
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE {
-                return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-            }
-        };
-        struct EndsWithMatcher : StringMatcherBase {
-            EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
-
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE {
-                return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
-            }
-        };
+        CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+        :   m_caseSensitivity( caseSensitivity ),
+            m_str( adjustString( str ) )
+        {}
+        std::string CasedString::adjustString( std::string const& str ) const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? toLower( str )
+                   : str;
+        }
+        std::string CasedString::caseSensitivitySuffix() const {
+            return m_caseSensitivity == CaseSensitive::No
+                   ? " (case insensitive)"
+                   : std::string();
+        }
 
-    } // namespace StdString
+
+        StringMatcherBase::StringMatcherBase( std::string operation, CasedString const& comparator )
+        : m_comparator( comparator ),
+          m_operation( operation ) {
+        }
+
+        std::string StringMatcherBase::toStringUncached() const {
+            std::string description;
+            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+                                        m_comparator.caseSensitivitySuffix().size());
+            description += m_operation;
+            description += ": \"";
+            description += m_comparator.m_str;
+            description += "\"";
+            description += m_comparator.caseSensitivitySuffix();
+            return description;
+        }
+
+        EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
+
+        bool EqualsMatcher::match( std::string const& source ) const {
+            return m_comparator.adjustString( source ) == m_comparator.m_str;
+        }
+
+
+        ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
+
+        bool ContainsMatcher::match( std::string const& source ) const {
+            return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
 
 
+        StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
 
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
+        bool StartsWithMatcher::match( std::string const& source ) const {
+            return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
 
-    inline StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) {
+
+        EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
+
+        bool EndsWithMatcher::match( std::string const& source ) const {
+            return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+        }
+
+    } // namespace StdString
+
+
+    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
         return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
     }
-    inline StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) {
+    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
         return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
     }
-    inline StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) {
+    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
         return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
     }
-    inline StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) {
+    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
         return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
     }
 
 } // namespace Matchers
 } // namespace Catch
-
-#endif // TWOBLUECUBES_CATCH_MATCHERS_STRING_HPP_INCLUDED