From f0890dcdf89d305862d0ba3518752c4becb65773 Mon Sep 17 00:00:00 2001
From: Phil Nash <github@philnash.me>
Date: Thu, 20 Jul 2017 15:57:17 +0100
Subject: [PATCH] removed redundant virtuals on override functions (and added a
 couple of overrides)

---
 include/internal/catch_config.hpp             | 26 ++++-----
 include/internal/catch_expression_lhs.hpp     | 10 ++--
 include/internal/catch_matchers.hpp           | 12 ++--
 include/internal/catch_matchers_string.h      | 10 ++--
 include/internal/catch_matchers_vector.h      |  6 +-
 include/internal/catch_objc.hpp               | 18 +++---
 include/internal/catch_registry_hub.cpp       | 22 ++++----
 include/internal/catch_reporter_registry.hpp  |  8 +--
 include/internal/catch_result_builder.h       |  2 +-
 include/internal/catch_stream.h               | 12 ++--
 include/internal/catch_tag_alias_registry.h   |  6 +-
 .../catch_test_case_registry_impl.hpp         |  4 +-
 include/internal/catch_test_case_tracker.hpp  | 40 ++++++-------
 include/reporters/catch_reporter_automake.hpp | 10 ++--
 include/reporters/catch_reporter_bases.hpp    | 56 +++++++++----------
 include/reporters/catch_reporter_compact.cpp  |  6 +-
 include/reporters/catch_reporter_console.cpp  | 19 +++----
 include/reporters/catch_reporter_junit.cpp    | 18 +++---
 include/reporters/catch_reporter_multi.h      | 41 +++++---------
 include/reporters/catch_reporter_tap.hpp      | 14 ++---
 include/reporters/catch_reporter_teamcity.hpp | 21 ++++---
 include/reporters/catch_reporter_xml.cpp      | 24 ++++----
 projects/SelfTest/MatchersTests.cpp           |  4 +-
 23 files changed, 183 insertions(+), 206 deletions(-)

diff --git a/include/internal/catch_config.hpp b/include/internal/catch_config.hpp
index 36894bec..531543c2 100644
--- a/include/internal/catch_config.hpp
+++ b/include/internal/catch_config.hpp
@@ -80,19 +80,19 @@ namespace Catch {
         bool showHelp() const;
 
         // IConfig interface
-        virtual bool allowThrows() const override;
-        virtual std::ostream& stream() const override;
-        virtual std::string name() const override;
-        virtual bool includeSuccessfulResults() const override;
-        virtual bool warnAboutMissingAssertions() const override;
-        virtual ShowDurations::OrNot showDurations() const override;
-        virtual RunTests::InWhatOrder runOrder() const override;
-        virtual unsigned int rngSeed() const override;
-        virtual UseColour::YesOrNo useColour() const override;
-        virtual bool shouldDebugBreak() const override;
-        virtual int abortAfter() const override;
-        virtual bool showInvisibles() const override;
-        virtual Verbosity verbosity() const override;
+        bool allowThrows() const override;
+        std::ostream& stream() const override;
+        std::string name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        ShowDurations::OrNot showDurations() const override;
+        RunTests::InWhatOrder runOrder() const override;
+        unsigned int rngSeed() const override;
+        UseColour::YesOrNo useColour() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
 
     private:
 
diff --git a/include/internal/catch_expression_lhs.hpp b/include/internal/catch_expression_lhs.hpp
index dc32fff7..67db9d65 100644
--- a/include/internal/catch_expression_lhs.hpp
+++ b/include/internal/catch_expression_lhs.hpp
@@ -81,7 +81,7 @@ public:
             .endExpression( *this );
     }
 
-    virtual void reconstructExpression( std::string& dest ) const override {
+    void reconstructExpression( std::string& dest ) const override {
         dest = ::Catch::Detail::stringify( m_lhs );
     }
 
@@ -117,11 +117,11 @@ public:
             .endExpression( *this );
     }
 
-    virtual bool isBinaryExpression() const override {
+    bool isBinaryExpression() const override {
         return true;
     }
 
-    virtual void reconstructExpression( std::string& dest ) const override {
+    void reconstructExpression( std::string& dest ) const override {
         std::string lhs = ::Catch::Detail::stringify( m_lhs );
         std::string rhs = ::Catch::Detail::stringify( m_rhs );
         char delim = lhs.size() + rhs.size() < 40 &&
@@ -151,11 +151,11 @@ public:
     MatchExpression( ArgT arg, MatcherT matcher, char const* matcherString )
         : m_arg( arg ), m_matcher( matcher ), m_matcherString( matcherString ) {}
 
-    virtual bool isBinaryExpression() const override {
+    bool isBinaryExpression() const override {
         return true;
     }
 
-    virtual void reconstructExpression( std::string& dest ) const override {
+    void reconstructExpression( std::string& dest ) const override {
         std::string matcherAsString = m_matcher.toString();
         dest = ::Catch::Detail::stringify( m_arg );
         dest += ' ';
diff --git a/include/internal/catch_matchers.hpp b/include/internal/catch_matchers.hpp
index 2083db73..4f41cb01 100644
--- a/include/internal/catch_matchers.hpp
+++ b/include/internal/catch_matchers.hpp
@@ -53,14 +53,14 @@ namespace Matchers {
 
         template<typename ArgT>
         struct MatchAllOf : MatcherBase<ArgT> {
-            virtual bool match( ArgT const& arg ) const override {
+            bool match( ArgT const& arg ) const override {
                 for( auto matcher : m_matchers ) {
                     if (!matcher->match(arg))
                         return false;
                 }
                 return true;
             }
-            virtual std::string describe() const override {
+            std::string describe() const override {
                 std::string description;
                 description.reserve( 4 + m_matchers.size()*32 );
                 description += "( ";
@@ -86,14 +86,14 @@ namespace Matchers {
         template<typename ArgT>
         struct MatchAnyOf : MatcherBase<ArgT> {
 
-            virtual bool match( ArgT const& arg ) const override {
+            bool match( ArgT const& arg ) const override {
                 for( auto matcher : m_matchers ) {
                     if (matcher->match(arg))
                         return true;
                 }
                 return false;
             }
-            virtual std::string describe() const override {
+            std::string describe() const override {
                 std::string description;
                 description.reserve( 4 + m_matchers.size()*32 );
                 description += "( ";
@@ -122,11 +122,11 @@ namespace Matchers {
 
             MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
 
-            virtual bool match( ArgT const& arg ) const override {
+            bool match( ArgT const& arg ) const override {
                 return !m_underlyingMatcher.match( arg );
             }
 
-            virtual std::string describe() const override {
+            std::string describe() const override {
                 return "not " + m_underlyingMatcher.toString();
             }
             MatcherBase<ArgT> const& m_underlyingMatcher;
diff --git a/include/internal/catch_matchers_string.h b/include/internal/catch_matchers_string.h
index 2192ee8f..eca35789 100644
--- a/include/internal/catch_matchers_string.h
+++ b/include/internal/catch_matchers_string.h
@@ -29,7 +29,7 @@ namespace Matchers {
 
         struct StringMatcherBase : MatcherBase<std::string> {
             StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            virtual std::string describe() const override;
+            std::string describe() const override;
 
             CasedString m_comparator;
             std::string m_operation;
@@ -37,19 +37,19 @@ namespace Matchers {
 
         struct EqualsMatcher : StringMatcherBase {
             EqualsMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const override;
+            bool match( std::string const& source ) const override;
         };
         struct ContainsMatcher : StringMatcherBase {
             ContainsMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const override;
+            bool match( std::string const& source ) const override;
         };
         struct StartsWithMatcher : StringMatcherBase {
             StartsWithMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const override;
+            bool match( std::string const& source ) const override;
         };
         struct EndsWithMatcher : StringMatcherBase {
             EndsWithMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const override;
+            bool match( std::string const& source ) const override;
         };
 
     } // namespace StdString
diff --git a/include/internal/catch_matchers_vector.h b/include/internal/catch_matchers_vector.h
index e80f7e12..1f9e0a61 100644
--- a/include/internal/catch_matchers_vector.h
+++ b/include/internal/catch_matchers_vector.h
@@ -24,7 +24,7 @@ namespace Matchers {
                 return std::find(v.begin(), v.end(), m_comparator) != v.end();
             }
 
-            virtual std::string describe() const override {
+            std::string describe() const override {
                 return "Contains: " + ::Catch::Detail::stringify( m_comparator );
             }
 
@@ -45,7 +45,7 @@ namespace Matchers {
                         return false;
                 return true;
             }
-            virtual std::string describe() const override {
+            std::string describe() const override {
                 return "Contains: " + ::Catch::Detail::stringify( m_comparator );
             }
 
@@ -69,7 +69,7 @@ namespace Matchers {
                         return false;
                 return true;
             }
-            virtual std::string describe() const override {
+            std::string describe() const override {
                 return "Equals: " + ::Catch::Detail::stringify( m_comparator );
             }
             std::vector<T> const& m_comparator;
diff --git a/include/internal/catch_objc.hpp b/include/internal/catch_objc.hpp
index 8b11d83e..350dc72c 100644
--- a/include/internal/catch_objc.hpp
+++ b/include/internal/catch_objc.hpp
@@ -112,7 +112,7 @@ namespace Catch {
                     arcSafeRelease( m_substr );
                 }
 
-                virtual bool match( NSString* arg ) const override {
+                bool match( NSString* arg ) const override {
                     return false;
                 }
 
@@ -122,12 +122,12 @@ namespace Catch {
             struct Equals : StringHolder {
                 Equals( NSString* substr ) : StringHolder( substr ){}
 
-                virtual bool match( NSString* str ) const override {
+                bool match( NSString* str ) const override {
                     return  (str != nil || m_substr == nil ) &&
                             [str isEqualToString:m_substr];
                 }
 
-                virtual std::string describe() const override {
+                std::string describe() const override {
                     return "equals string: " + Catch::toString( m_substr );
                 }
             };
@@ -135,12 +135,12 @@ namespace Catch {
             struct Contains : StringHolder {
                 Contains( NSString* substr ) : StringHolder( substr ){}
 
-                virtual bool match( NSString* str ) const {
+                bool match( NSString* str ) const {
                     return  (str != nil || m_substr == nil ) &&
                             [str rangeOfString:m_substr].location != NSNotFound;
                 }
 
-                virtual std::string describe() const override {
+                std::string describe() const override {
                     return "contains string: " + Catch::toString( m_substr );
                 }
             };
@@ -148,24 +148,24 @@ namespace Catch {
             struct StartsWith : StringHolder {
                 StartsWith( NSString* substr ) : StringHolder( substr ){}
 
-                virtual bool match( NSString* str ) const {
+                bool match( NSString* str ) const override {
                     return  (str != nil || m_substr == nil ) &&
                             [str rangeOfString:m_substr].location == 0;
                 }
 
-                virtual std::string describe() const override {
+                std::string describe() const override {
                     return "starts with: " + Catch::toString( m_substr );
                 }
             };
             struct EndsWith : StringHolder {
                 EndsWith( NSString* substr ) : StringHolder( substr ){}
 
-                virtual bool match( NSString* str ) const {
+                bool match( NSString* str ) const override {
                     return  (str != nil || m_substr == nil ) &&
                             [str rangeOfString:m_substr].location == [str length] - [m_substr length];
                 }
 
-                virtual std::string describe() const override {
+                std::string describe() const override {
                     return "ends with: " + Catch::toString( m_substr );
                 }
             };
diff --git a/include/internal/catch_registry_hub.cpp b/include/internal/catch_registry_hub.cpp
index 12af6e38..01208e77 100644
--- a/include/internal/catch_registry_hub.cpp
+++ b/include/internal/catch_registry_hub.cpp
@@ -24,39 +24,39 @@ namespace Catch {
         public: // IRegistryHub
             RegistryHub() {
             }
-            virtual IReporterRegistry const& getReporterRegistry() const override {
+            IReporterRegistry const& getReporterRegistry() const override {
                 return m_reporterRegistry;
             }
-            virtual ITestCaseRegistry const& getTestCaseRegistry() const override {
+            ITestCaseRegistry const& getTestCaseRegistry() const override {
                 return m_testCaseRegistry;
             }
-            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() override {
+            IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() override {
                 return m_exceptionTranslatorRegistry;
             }
-            virtual ITagAliasRegistry const& getTagAliasRegistry() const override {
+            ITagAliasRegistry const& getTagAliasRegistry() const override {
                 return m_tagAliasRegistry;
             }
-            virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
                 return m_exceptionRegistry;
             }
 
         public: // IMutableRegistryHub
-            virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
+            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
                 m_reporterRegistry.registerReporter( name, factory );
             }
-            virtual void registerListener( IReporterFactoryPtr const& factory ) override {
+            void registerListener( IReporterFactoryPtr const& factory ) override {
                 m_reporterRegistry.registerListener( factory );
             }
-            virtual void registerTest( TestCase const& testInfo ) override {
+            void registerTest( TestCase const& testInfo ) override {
                 m_testCaseRegistry.registerTest( testInfo );
             }
-            virtual void registerTranslator( const IExceptionTranslator* translator ) override {
+            void registerTranslator( const IExceptionTranslator* translator ) override {
                 m_exceptionTranslatorRegistry.registerTranslator( translator );
             }
-            virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
                 m_tagAliasRegistry.add( alias, tag, lineInfo );
             }
-            virtual void registerStartupException( std::exception_ptr const& exception ) noexcept override {
+            void registerStartupException( std::exception_ptr const& exception ) noexcept override {
                 m_exceptionRegistry.add(exception);
             }
 
diff --git a/include/internal/catch_reporter_registry.hpp b/include/internal/catch_reporter_registry.hpp
index 9556fb31..0c015fb9 100644
--- a/include/internal/catch_reporter_registry.hpp
+++ b/include/internal/catch_reporter_registry.hpp
@@ -18,9 +18,9 @@ namespace Catch {
 
     public:
 
-        virtual ~ReporterRegistry() override {}
+        ~ReporterRegistry() override {}
 
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override {
+        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override {
             FactoryMap::const_iterator it =  m_factories.find( name );
             if( it == m_factories.end() )
                 return nullptr;
@@ -34,10 +34,10 @@ namespace Catch {
             m_listeners.push_back( factory );
         }
 
-        virtual FactoryMap const& getFactories() const override {
+        FactoryMap const& getFactories() const override {
             return m_factories;
         }
-        virtual Listeners const& getListeners() const override {
+        Listeners const& getListeners() const override {
             return m_listeners;
         }
 
diff --git a/include/internal/catch_result_builder.h b/include/internal/catch_result_builder.h
index d442ce40..4c5c5d80 100644
--- a/include/internal/catch_result_builder.h
+++ b/include/internal/catch_result_builder.h
@@ -50,7 +50,7 @@ namespace Catch {
 
         void endExpression( DecomposedExpression const& expr );
 
-        virtual void reconstructExpression( std::string& dest ) const override;
+        void reconstructExpression( std::string& dest ) const override;
 
         AssertionResult build() const;
         AssertionResult build( DecomposedExpression const& expr ) const;
diff --git a/include/internal/catch_stream.h b/include/internal/catch_stream.h
index baa10c44..8f2fb5a6 100644
--- a/include/internal/catch_stream.h
+++ b/include/internal/catch_stream.h
@@ -31,9 +31,9 @@ namespace Catch {
         mutable std::ofstream m_ofs;
     public:
         FileStream( std::string const& filename );
-        virtual ~FileStream() noexcept;
+        ~FileStream() noexcept override;
     public: // IStream
-        virtual std::ostream& stream() const override;
+        std::ostream& stream() const override;
     };
 
 
@@ -41,10 +41,10 @@ namespace Catch {
         mutable std::ostream m_os;
     public:
         CoutStream();
-        virtual ~CoutStream() noexcept;
+        ~CoutStream() noexcept override;
 
     public: // IStream
-        virtual std::ostream& stream() const override;
+        std::ostream& stream() const override;
     };
 
 
@@ -53,10 +53,10 @@ namespace Catch {
         mutable std::ostream m_os;
     public:
         DebugOutStream();
-        virtual ~DebugOutStream() noexcept;
+        ~DebugOutStream() noexcept override;
 
     public: // IStream
-        virtual std::ostream& stream() const override;
+        std::ostream& stream() const override;
     };
 }
 
diff --git a/include/internal/catch_tag_alias_registry.h b/include/internal/catch_tag_alias_registry.h
index aea41275..d05c7739 100644
--- a/include/internal/catch_tag_alias_registry.h
+++ b/include/internal/catch_tag_alias_registry.h
@@ -16,9 +16,9 @@ namespace Catch {
 
     class TagAliasRegistry : public ITagAliasRegistry {
     public:
-        virtual ~TagAliasRegistry();
-        virtual Option<TagAlias> find( std::string const& alias ) const;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
+        ~TagAliasRegistry() override;
+        Option<TagAlias> find( std::string const& alias ) const override;
+        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
         void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
 
     private:
diff --git a/include/internal/catch_test_case_registry_impl.hpp b/include/internal/catch_test_case_registry_impl.hpp
index 5bb32f5e..068ffe58 100644
--- a/include/internal/catch_test_case_registry_impl.hpp
+++ b/include/internal/catch_test_case_registry_impl.hpp
@@ -96,10 +96,10 @@ namespace Catch {
             m_functions.push_back( testCase );
         }
 
-        virtual std::vector<TestCase> const& getAllTests() const {
+        std::vector<TestCase> const& getAllTests() const override {
             return m_functions;
         }
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const {
+        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override {
             if( m_sortedFunctions.empty() )
                 enforceNoDuplicateTestCases( m_functions );
 
diff --git a/include/internal/catch_test_case_tracker.hpp b/include/internal/catch_test_case_tracker.hpp
index 964b45f9..39509300 100644
--- a/include/internal/catch_test_case_tracker.hpp
+++ b/include/internal/catch_test_case_tracker.hpp
@@ -59,7 +59,7 @@ namespace TestCaseTracking {
         virtual bool isIndexTracker() const = 0;
     };
 
-    class  TrackerContext {
+    class TrackerContext {
 
         enum RunState {
             NotStarted,
@@ -113,30 +113,29 @@ namespace TestCaseTracking {
 
     public:
         TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-        virtual ~TrackerBase() = default;
 
-        virtual NameAndLocation const& nameAndLocation() const override;
-        virtual bool isComplete() const override;
-        virtual bool isSuccessfullyCompleted() const override;
-        virtual bool isOpen() const override;
-        virtual bool hasChildren() const override;
+        NameAndLocation const& nameAndLocation() const override;
+        bool isComplete() const override;
+        bool isSuccessfullyCompleted() const override;
+        bool isOpen() const override;
+        bool hasChildren() const override;
 
 
-        virtual void addChild( ITrackerPtr const& child ) override;
+        void addChild( ITrackerPtr const& child ) override;
 
-        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
-        virtual ITracker& parent() override;
+        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
+        ITracker& parent() override;
 
-        virtual void openChild() override;
+        void openChild() override;
 
-        virtual bool isSectionTracker() const override;
-        virtual bool isIndexTracker() const override;
+        bool isSectionTracker() const override;
+        bool isIndexTracker() const override;
 
         void open();
 
-        virtual void close() override;
-        virtual void fail() override;
-        virtual void markAsNeedingAnotherRun() override;
+        void close() override;
+        void fail() override;
+        void markAsNeedingAnotherRun() override;
 
     private:
         void moveToParent();
@@ -147,9 +146,8 @@ namespace TestCaseTracking {
         std::vector<std::string> m_filters;
     public:
         SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
-        virtual ~SectionTracker() = default;
 
-        virtual bool isSectionTracker() const override;
+        bool isSectionTracker() const override;
 
         static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
 
@@ -164,17 +162,15 @@ namespace TestCaseTracking {
         int m_index = -1;
     public:
         IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size );
-        virtual ~IndexTracker() = default;
 
-        virtual bool isIndexTracker() const override;
+        bool isIndexTracker() const override;
+        void close() override;
 
         static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size );
 
         int index() const;
 
         void moveNext();
-
-        virtual void close() override;
     };
 
 } // namespace TestCaseTracking
diff --git a/include/reporters/catch_reporter_automake.hpp b/include/reporters/catch_reporter_automake.hpp
index 7a841a1a..86eb0325 100644
--- a/include/reporters/catch_reporter_automake.hpp
+++ b/include/reporters/catch_reporter_automake.hpp
@@ -21,17 +21,17 @@ namespace Catch {
           :   StreamingReporterBase( _config )
         {}
 
-        virtual ~AutomakeReporter();
+        ~AutomakeReporter() override;
 
         static std::string getDescription() {
             return "Reports test results in the format of Automake .trs files";
         }
 
-        virtual void assertionStarting( AssertionInfo const& ) override {}
+        void assertionStarting( AssertionInfo const& ) override {}
 
-        virtual bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
+        bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
 
-        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
+        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
             // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
             stream << ":test-result: ";
             if (_testCaseStats.totals.assertions.allPassed()) {
@@ -45,7 +45,7 @@ namespace Catch {
             StreamingReporterBase::testCaseEnded( _testCaseStats );
         }
 
-        virtual void skipTest( TestCaseInfo const& testInfo ) override {
+        void skipTest( TestCaseInfo const& testInfo ) override {
             stream << ":test-result: SKIP " << testInfo.name << '\n';
         }
 
diff --git a/include/reporters/catch_reporter_bases.hpp b/include/reporters/catch_reporter_bases.hpp
index ccb44f00..85adc18f 100644
--- a/include/reporters/catch_reporter_bases.hpp
+++ b/include/reporters/catch_reporter_bases.hpp
@@ -32,7 +32,7 @@ namespace Catch {
             CATCH_ENFORCE( DerivedT::getSupportedVerbosities().count( m_config->verbosity() ), "Verbosity level not supported by this reporter" );
         }
 
-        virtual ReporterPreferences getPreferences() const override {
+        ReporterPreferences getPreferences() const override {
             return m_reporterPrefs;
         }
 
@@ -40,40 +40,40 @@ namespace Catch {
             return { Verbosity::Normal };
         }
 
-        virtual ~StreamingReporterBase() override = default;
+        ~StreamingReporterBase() override = default;
 
-        virtual void noMatchingTestCases(std::string const&) override {}
+        void noMatchingTestCases(std::string const&) override {}
 
-        virtual void testRunStarting(TestRunInfo const& _testRunInfo) override {
+        void testRunStarting(TestRunInfo const& _testRunInfo) override {
             currentTestRunInfo = _testRunInfo;
         }
-        virtual void testGroupStarting(GroupInfo const& _groupInfo) override {
+        void testGroupStarting(GroupInfo const& _groupInfo) override {
             currentGroupInfo = _groupInfo;
         }
 
-        virtual void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
             currentTestCaseInfo = _testInfo;
         }
-        virtual void sectionStarting(SectionInfo const& _sectionInfo) override {
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
             m_sectionStack.push_back(_sectionInfo);
         }
 
-        virtual void sectionEnded(SectionStats const& /* _sectionStats */) override {
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
             m_sectionStack.pop_back();
         }
-        virtual void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
             currentTestCaseInfo.reset();
         }
-        virtual void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
             currentGroupInfo.reset();
         }
-        virtual void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
             currentTestCaseInfo.reset();
             currentGroupInfo.reset();
             currentTestRunInfo.reset();
         }
 
-        virtual void skipTest(TestCaseInfo const&) override {
+        void skipTest(TestCaseInfo const&) override {
             // Don't do anything with this by default.
             // It can optionally be overridden in the derived class.
         }
@@ -144,9 +144,9 @@ namespace Catch {
             m_reporterPrefs.shouldRedirectStdOut = false;
             CATCH_ENFORCE( DerivedT::getSupportedVerbosities().count( m_config->verbosity() ), "Verbosity level not supported by this reporter" );
         }
-        virtual ~CumulativeReporterBase() = default;
+        ~CumulativeReporterBase() override = default;
 
-        virtual ReporterPreferences getPreferences() const override {
+        ReporterPreferences getPreferences() const override {
             return m_reporterPrefs;
         }
 
@@ -154,12 +154,12 @@ namespace Catch {
             return { Verbosity::Normal };
         }
 
-        virtual void testRunStarting( TestRunInfo const& ) override {}
-        virtual void testGroupStarting( GroupInfo const& ) override {}
+        void testRunStarting( TestRunInfo const& ) override {}
+        void testGroupStarting( GroupInfo const& ) override {}
 
-        virtual void testCaseStarting( TestCaseInfo const& ) override {}
+        void testCaseStarting( TestCaseInfo const& ) override {}
 
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) override {
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
             SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
             std::shared_ptr<SectionNode> node;
             if( m_sectionStack.empty() ) {
@@ -184,9 +184,9 @@ namespace Catch {
             m_deepestSection = node;
         }
 
-        virtual void assertionStarting(AssertionInfo const&) override {}
+        void assertionStarting(AssertionInfo const&) override {}
 
-        virtual bool assertionEnded(AssertionStats const& assertionStats) override {
+        bool assertionEnded(AssertionStats const& assertionStats) override {
             assert(!m_sectionStack.empty());
             SectionNode& sectionNode = *m_sectionStack.back();
             sectionNode.assertions.push_back(assertionStats);
@@ -198,13 +198,13 @@ namespace Catch {
             prepareExpandedExpression(sectionNode.assertions.back().assertionResult);
             return true;
         }
-        virtual void sectionEnded(SectionStats const& sectionStats) override {
+        void sectionEnded(SectionStats const& sectionStats) override {
             assert(!m_sectionStack.empty());
             SectionNode& node = *m_sectionStack.back();
             node.stats = sectionStats;
             m_sectionStack.pop_back();
         }
-        virtual void testCaseEnded(TestCaseStats const& testCaseStats) override {
+        void testCaseEnded(TestCaseStats const& testCaseStats) override {
             auto node = std::make_shared<TestCaseNode>(testCaseStats);
             assert(m_sectionStack.size() == 0);
             node->children.push_back(m_rootSection);
@@ -215,12 +215,12 @@ namespace Catch {
             m_deepestSection->stdOut = testCaseStats.stdOut;
             m_deepestSection->stdErr = testCaseStats.stdErr;
         }
-        virtual void testGroupEnded(TestGroupStats const& testGroupStats) override {
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
             auto node = std::make_shared<TestGroupNode>(testGroupStats);
             node->children.swap(m_testCases);
             m_testGroups.push_back(node);
         }
-        virtual void testRunEnded(TestRunStats const& testRunStats) override {
+        void testRunEnded(TestRunStats const& testRunStats) override {
             auto node = std::make_shared<TestRunNode>(testRunStats);
             node->children.swap(m_testGroups);
             m_testRuns.push_back(node);
@@ -228,9 +228,9 @@ namespace Catch {
         }
         virtual void testRunEndedCumulative() = 0;
 
-        virtual void skipTest(TestCaseInfo const&) override {}
+        void skipTest(TestCaseInfo const&) override {}
 
-        virtual void prepareExpandedExpression(AssertionResult& result) const {
+        void prepareExpandedExpression(AssertionResult& result) const {
             if (result.isOk())
                 result.discardDecomposedExpression();
             else
@@ -266,8 +266,8 @@ namespace Catch {
     struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
         TestEventListenerBase( ReporterConfig const& _config );
 
-        virtual void assertionStarting(AssertionInfo const&) override;
-        virtual bool assertionEnded(AssertionStats const&) override;
+        void assertionStarting(AssertionInfo const&) override;
+        bool assertionEnded(AssertionStats const&) override;
     };
 
 } // end namespace Catch
diff --git a/include/reporters/catch_reporter_compact.cpp b/include/reporters/catch_reporter_compact.cpp
index 7ad9d6b0..1c4b9d56 100644
--- a/include/reporters/catch_reporter_compact.cpp
+++ b/include/reporters/catch_reporter_compact.cpp
@@ -17,7 +17,7 @@ namespace Catch {
 
         using StreamingReporterBase::StreamingReporterBase;
 
-        virtual ~CompactReporter();
+        ~CompactReporter() override;
 
         static std::string getDescription() {
             return "Reports test results on a single line, suitable for IDEs";
@@ -54,7 +54,7 @@ namespace Catch {
             return true;
         }
 
-        virtual void sectionEnded(SectionStats const& _sectionStats) override {
+        void sectionEnded(SectionStats const& _sectionStats) override {
             if (m_config->showDurations() == ShowDurations::Always) {
                 stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
             }
@@ -73,7 +73,6 @@ namespace Catch {
             AssertionPrinter( AssertionPrinter const& ) = delete;
             AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
             : stream( _stream )
-            , stats( _stats )
             , result( _stats.assertionResult )
             , messages( _stats.infoMessages )
             , itMessage( _stats.infoMessages.begin() )
@@ -241,7 +240,6 @@ namespace Catch {
 
         private:
             std::ostream& stream;
-            AssertionStats const& stats;
             AssertionResult const& result;
             std::vector<MessageInfo> messages;
             std::vector<MessageInfo>::const_iterator itMessage;
diff --git a/include/reporters/catch_reporter_console.cpp b/include/reporters/catch_reporter_console.cpp
index 228abc3f..3643c1df 100644
--- a/include/reporters/catch_reporter_console.cpp
+++ b/include/reporters/catch_reporter_console.cpp
@@ -22,19 +22,18 @@ namespace Catch {
         using StreamingReporterBase::StreamingReporterBase;
 
 
-        virtual ~ConsoleReporter() override;
+        ~ConsoleReporter() override;
         static std::string getDescription() {
             return "Reports test results as plain lines of text";
         }
 
-        virtual void noMatchingTestCases( std::string const& spec ) override {
+        void noMatchingTestCases( std::string const& spec ) override {
             stream << "No test cases matched '" << spec << '\'' << std::endl;
         }
 
-        virtual void assertionStarting( AssertionInfo const& ) override {
-        }
+        void assertionStarting( AssertionInfo const& ) override {}
 
-        virtual bool assertionEnded( AssertionStats const& _assertionStats ) override {
+        bool assertionEnded( AssertionStats const& _assertionStats ) override {
             AssertionResult const& result = _assertionStats.assertionResult;
 
             bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
@@ -51,11 +50,11 @@ namespace Catch {
             return true;
         }
 
-        virtual void sectionStarting( SectionInfo const& _sectionInfo ) override {
+        void sectionStarting( SectionInfo const& _sectionInfo ) override {
             m_headerPrinted = false;
             StreamingReporterBase::sectionStarting( _sectionInfo );
         }
-        virtual void sectionEnded( SectionStats const& _sectionStats ) override {
+        void sectionEnded( SectionStats const& _sectionStats ) override {
             if( _sectionStats.missingAssertions ) {
                 lazyPrint();
                 Colour colour( Colour::ResultError );
@@ -74,11 +73,11 @@ namespace Catch {
             StreamingReporterBase::sectionEnded( _sectionStats );
         }
 
-        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
+        void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
             StreamingReporterBase::testCaseEnded( _testCaseStats );
             m_headerPrinted = false;
         }
-        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) override {
+        void testGroupEnded( TestGroupStats const& _testGroupStats ) override {
             if( currentGroupInfo.used ) {
                 printSummaryDivider();
                 stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
@@ -87,7 +86,7 @@ namespace Catch {
             }
             StreamingReporterBase::testGroupEnded( _testGroupStats );
         }
-        virtual void testRunEnded( TestRunStats const& _testRunStats ) override {
+        void testRunEnded( TestRunStats const& _testRunStats ) override {
             printTotalsDivider( _testRunStats.totals );
             printTotals( _testRunStats.totals );
             stream << std::endl;
diff --git a/include/reporters/catch_reporter_junit.cpp b/include/reporters/catch_reporter_junit.cpp
index ca933e3e..1235281a 100644
--- a/include/reporters/catch_reporter_junit.cpp
+++ b/include/reporters/catch_reporter_junit.cpp
@@ -57,20 +57,20 @@ namespace Catch {
             m_reporterPrefs.shouldRedirectStdOut = true;
         }
 
-        virtual ~JunitReporter() override;
+        ~JunitReporter() override;
 
         static std::string getDescription() {
             return "Reports test results in an XML format that looks like Ant's junitreport target";
         }
 
-        virtual void noMatchingTestCases( std::string const& /*spec*/ ) override {}
+        void noMatchingTestCases( std::string const& /*spec*/ ) override {}
 
-        virtual void testRunStarting( TestRunInfo const& runInfo ) override {
+        void testRunStarting( TestRunInfo const& runInfo ) override {
             CumulativeReporterBase::testRunStarting( runInfo );
             xml.startElement( "testsuites" );
         }
 
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) override {
+        void testGroupStarting( GroupInfo const& groupInfo ) override {
             suiteTimer.start();
             stdOutForSuite.str("");
             stdErrForSuite.str("");
@@ -78,28 +78,28 @@ namespace Catch {
             CumulativeReporterBase::testGroupStarting( groupInfo );
         }
 
-        virtual void testCaseStarting( TestCaseInfo const& testCaseInfo ) override {
+        void testCaseStarting( TestCaseInfo const& testCaseInfo ) override {
             m_okToFail = testCaseInfo.okToFail();
         }
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) override {
+        bool assertionEnded( AssertionStats const& assertionStats ) override {
             if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
                 unexpectedExceptions++;
             return CumulativeReporterBase::assertionEnded( assertionStats );
         }
 
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
             stdOutForSuite << testCaseStats.stdOut;
             stdErrForSuite << testCaseStats.stdErr;
             CumulativeReporterBase::testCaseEnded( testCaseStats );
         }
 
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) override {
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
             double suiteTime = suiteTimer.getElapsedSeconds();
             CumulativeReporterBase::testGroupEnded( testGroupStats );
             writeGroup( *m_testGroups.back(), suiteTime );
         }
 
-        virtual void testRunEndedCumulative() override {
+        void testRunEndedCumulative() override {
             xml.endElement();
         }
 
diff --git a/include/reporters/catch_reporter_multi.h b/include/reporters/catch_reporter_multi.h
index ab6d5077..ce9bb87d 100644
--- a/include/reporters/catch_reporter_multi.h
+++ b/include/reporters/catch_reporter_multi.h
@@ -18,40 +18,27 @@ namespace Catch {
 
     public: // IStreamingReporter
 
-        virtual ReporterPreferences getPreferences() const override;
+        ReporterPreferences getPreferences() const override;
 
-        virtual void noMatchingTestCases( std::string const& spec ) override;
+        void noMatchingTestCases( std::string const& spec ) override;
 
     static std::set<Verbosity> getSupportedVerbosities();
 
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) override;
-
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) override;
-
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) override;
-
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) override;
-
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) override;
-
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testGroupStarting( GroupInfo const& groupInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
 
         // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) override;
+        bool assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
 
-        virtual void sectionEnded( SectionStats const& sectionStats ) override;
-
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) override;
-
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) override;
-
-        virtual void testRunEnded( TestRunStats const& testRunStats ) override;
-
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) override;
-
-        virtual bool isMulti() const override;
+        void skipTest( TestCaseInfo const& testInfo ) override;
+        bool isMulti() const override;
 
     };
 
diff --git a/include/reporters/catch_reporter_tap.hpp b/include/reporters/catch_reporter_tap.hpp
index 00bd017d..1d1093b8 100644
--- a/include/reporters/catch_reporter_tap.hpp
+++ b/include/reporters/catch_reporter_tap.hpp
@@ -23,25 +23,25 @@ namespace Catch {
 
         using StreamingReporterBase::StreamingReporterBase;
 
-        virtual ~TAPReporter();
+        ~TAPReporter() override;
 
         static std::string getDescription() {
             return "Reports test results in TAP format, suitable for test harneses";
         }
 
-        virtual ReporterPreferences getPreferences() const {
+        ReporterPreferences getPreferences() const override {
             ReporterPreferences prefs;
             prefs.shouldRedirectStdOut = false;
             return prefs;
         }
 
-        virtual void noMatchingTestCases( std::string const& spec ) {
+        void noMatchingTestCases( std::string const& spec ) override {
             stream << "# No test cases matched '" << spec << "'" << std::endl;
         }
 
-        virtual void assertionStarting( AssertionInfo const& ) {}
+        void assertionStarting( AssertionInfo const& ) override {}
 
-        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+        bool assertionEnded( AssertionStats const& _assertionStats ) override {
             ++counter;
 
             AssertionPrinter printer( stream, _assertionStats, counter );
@@ -52,7 +52,7 @@ namespace Catch {
             return true;
         }
 
-        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+        void testRunEnded( TestRunStats const& _testRunStats ) override {
             printTotals( _testRunStats.totals );
             stream << "\n" << std::endl;
             StreamingReporterBase::testRunEnded( _testRunStats );
@@ -66,7 +66,6 @@ namespace Catch {
             AssertionPrinter( AssertionPrinter const& ) = delete;
             AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, size_t counter )
             : stream( _stream )
-            , stats( _stats )
             , result( _stats.assertionResult )
             , messages( _stats.infoMessages )
             , itMessage( _stats.infoMessages.begin() )
@@ -229,7 +228,6 @@ namespace Catch {
 
         private:
             std::ostream& stream;
-            AssertionStats const& stats;
             AssertionResult const& result;
             std::vector<MessageInfo> messages;
             std::vector<MessageInfo>::const_iterator itMessage;
diff --git a/include/reporters/catch_reporter_teamcity.hpp b/include/reporters/catch_reporter_teamcity.hpp
index a0252407..c9280a69 100644
--- a/include/reporters/catch_reporter_teamcity.hpp
+++ b/include/reporters/catch_reporter_teamcity.hpp
@@ -42,33 +42,32 @@ namespace Catch {
             replaceInPlace( escaped, "]", "|]" );
             return escaped;
         }
-        virtual ~TeamCityReporter() override;
+        ~TeamCityReporter() override;
 
         static std::string getDescription() {
             return "Reports test results as TeamCity service messages";
         }
 
-        virtual void skipTest( TestCaseInfo const& /* testInfo */ ) override {
+        void skipTest( TestCaseInfo const& /* testInfo */ ) override {
         }
 
-        virtual void noMatchingTestCases( std::string const& /* spec */ ) override {}
+        void noMatchingTestCases( std::string const& /* spec */ ) override {}
 
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) override {
+        void testGroupStarting( GroupInfo const& groupInfo ) override {
             StreamingReporterBase::testGroupStarting( groupInfo );
             stream << "##teamcity[testSuiteStarted name='"
                 << escape( groupInfo.name ) << "']\n";
         }
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) override {
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
             StreamingReporterBase::testGroupEnded( testGroupStats );
             stream << "##teamcity[testSuiteFinished name='"
                 << escape( testGroupStats.groupInfo.name ) << "']\n";
         }
 
 
-        virtual void assertionStarting( AssertionInfo const& ) override {
-        }
+        void assertionStarting( AssertionInfo const& ) override {}
 
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) override {
+        bool assertionEnded( AssertionStats const& assertionStats ) override {
             AssertionResult const& result = assertionStats.assertionResult;
             if( !result.isOk() ) {
 
@@ -139,19 +138,19 @@ namespace Catch {
             return true;
         }
 
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) override {
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
             m_headerPrintedForThisSection = false;
             StreamingReporterBase::sectionStarting( sectionInfo );
         }
 
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) override {
+        void testCaseStarting( TestCaseInfo const& testInfo ) override {
             m_testTimer.start();
             StreamingReporterBase::testCaseStarting( testInfo );
             stream << "##teamcity[testStarted name='"
                 << escape( testInfo.name ) << "']\n";
         }
 
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
             StreamingReporterBase::testCaseEnded( testCaseStats );
             if( !testCaseStats.stdOut.empty() )
                 stream << "##teamcity[testStdOut name='"
diff --git a/include/reporters/catch_reporter_xml.cpp b/include/reporters/catch_reporter_xml.cpp
index 3685f0d4..9e2ed08b 100644
--- a/include/reporters/catch_reporter_xml.cpp
+++ b/include/reporters/catch_reporter_xml.cpp
@@ -23,7 +23,7 @@ namespace Catch {
             m_reporterPrefs.shouldRedirectStdOut = true;
         }
 
-        virtual ~XmlReporter() override;
+        ~XmlReporter() override;
 
         static std::string getDescription() {
             return "Reports test results as an XML document";
@@ -41,11 +41,11 @@ namespace Catch {
 
     public: // StreamingReporterBase
 
-        virtual void noMatchingTestCases( std::string const& s ) override {
+        void noMatchingTestCases( std::string const& s ) override {
             StreamingReporterBase::noMatchingTestCases( s );
         }
 
-        virtual void testRunStarting( TestRunInfo const& testInfo ) override {
+        void testRunStarting( TestRunInfo const& testInfo ) override {
             StreamingReporterBase::testRunStarting( testInfo );
             std::string stylesheetRef = getStylesheetRef();
             if( !stylesheetRef.empty() )
@@ -55,13 +55,13 @@ namespace Catch {
                 m_xml.writeAttribute( "name", m_config->name() );
         }
 
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) override {
+        void testGroupStarting( GroupInfo const& groupInfo ) override {
             StreamingReporterBase::testGroupStarting( groupInfo );
             m_xml.startElement( "Group" )
                 .writeAttribute( "name", groupInfo.name );
         }
 
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) override {
+        void testCaseStarting( TestCaseInfo const& testInfo ) override {
             StreamingReporterBase::testCaseStarting(testInfo);
             m_xml.startElement( "TestCase" )
                 .writeAttribute( "name", trim( testInfo.name ) )
@@ -75,7 +75,7 @@ namespace Catch {
             m_xml.ensureTagClosed();
         }
 
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) override {
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
             StreamingReporterBase::sectionStarting( sectionInfo );
             if( m_sectionDepth++ > 0 ) {
                 m_xml.startElement( "Section" )
@@ -86,9 +86,9 @@ namespace Catch {
             }
         }
 
-        virtual void assertionStarting( AssertionInfo const& ) override { }
+        void assertionStarting( AssertionInfo const& ) override { }
 
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) override {
+        bool assertionEnded( AssertionStats const& assertionStats ) override {
 
             AssertionResult const& result = assertionStats.assertionResult;
 
@@ -163,7 +163,7 @@ namespace Catch {
             return true;
         }
 
-        virtual void sectionEnded( SectionStats const& sectionStats ) override {
+        void sectionEnded( SectionStats const& sectionStats ) override {
             StreamingReporterBase::sectionEnded( sectionStats );
             if( --m_sectionDepth > 0 ) {
                 XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
@@ -178,7 +178,7 @@ namespace Catch {
             }
         }
 
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) override {
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override {
             StreamingReporterBase::testCaseEnded( testCaseStats );
             XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
             e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
@@ -194,7 +194,7 @@ namespace Catch {
             m_xml.endElement();
         }
 
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) override {
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override {
             StreamingReporterBase::testGroupEnded( testGroupStats );
             // TODO: Check testGroupStats.aborting and act accordingly.
             m_xml.scopedElement( "OverallResults" )
@@ -204,7 +204,7 @@ namespace Catch {
             m_xml.endElement();
         }
 
-        virtual void testRunEnded( TestRunStats const& testRunStats ) override {
+        void testRunEnded( TestRunStats const& testRunStats ) override {
             StreamingReporterBase::testRunEnded( testRunStats );
             m_xml.scopedElement( "OverallResults" )
                 .writeAttribute( "successes", testRunStats.totals.assertions.passed )
diff --git a/projects/SelfTest/MatchersTests.cpp b/projects/SelfTest/MatchersTests.cpp
index a4f8a45f..814577e9 100644
--- a/projects/SelfTest/MatchersTests.cpp
+++ b/projects/SelfTest/MatchersTests.cpp
@@ -192,11 +192,11 @@ class ExceptionMatcher : public Catch::MatcherBase<SpecialException> {
     int m_expected;
 public:
     ExceptionMatcher(int i):m_expected(i) {}
-    virtual bool match(SpecialException const& se) const override {
+    bool match(SpecialException const& se) const override {
         return se.i == m_expected;
     }
 
-    virtual std::string describe() const override {
+    std::string describe() const override {
         std::ostringstream ss;
         ss << "special exception has value of " << m_expected;
         return ss.str();