Playing with Default behavior for catch-all blocks

test/plugin/ExceptionTest.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 33 matching lines @@
      * You might think that the next set would be EXPECT_EQ betwwen the thrown exception and the original one.
      * Such a test does not pass, nor is in necessary.
      * The throw statement above is throwing by value, so it makes a copy.
      */
   }
   try
   {
     rethrow_exception(ep);
     FAIL() << "Statement after 'rethrow_exception' executed.";
   }
-  catch (std::runtime_error& ex)
+  catch (const std::runtime_error& ex)
   {
     EXPECT_STREQ(e.what(), ex.what());
     return;
   }
   catch (...)
   {
     FAIL() << "Rethrown exception isn't the same type as the original";
   }
   FAIL() << "Did not return after catching rethrown exception";
 }
 
 /*
  * A plain exception, not a subclass of std::runtime_error or std::logic_error.
  */
 class PlainException
   : public std::exception
 {
   const char* what() const override
   {
     return "Plain";
   };
 };
 
 struct NullHandlers
 {
-  static void Unknown(int y) {}
-  static void Exception(std::exception& ex,int y) {}
-  static void LogicError(std::logic_error& ex,int y) { Exception(ex, y); }
-  static void RuntimeError(std::runtime_error& ex,int y) { Exception(ex, y); }
-  static void SystemError(std::system_error& ex,int y) { RuntimeError(ex, y); }
+  static void Unknown(int) {}
+  static void Exception(const std::exception&,int) {}
 };
 
 /*
  * The trivial tests assure that nothing escapes the catch-all function,
  *   that is, we ensure that nothing is thrown or rethrown.
  */
 template<class X>
 void TrivialVoid(X x)
 {
   ASSERT_NO_THROW(
@@ skipping 27 matching lines @@
 TEST(Exception, TrivialVoidRuntimeError)
 {
   TrivialVoid(std::runtime_error(""));
 }
 
 TEST(Exception, TrivialVoidSystemError)
 {
   TrivialVoid(std::system_error(std::error_code()));
 }
 
-enum
+enum class ReturnType
 {
   InvalidCode = -1,
   UnknownCode = 1,
   ExceptionCode,
   LogicErrorCode,
   RuntimeErrorCode,
   SystemErrorCode
 };
 
 struct NullHandlersReturn
 {
-  typedef int ReturnType;
-  static ReturnType Unknown(int) { return UnknownCode; }
-  static ReturnType Exception(std::exception& ex, int) { return ExceptionCode; }
-  static ReturnType LogicError(std::logic_error& ex, int) { return LogicErrorCode; }
-  static ReturnType RuntimeError(std::runtime_error& ex, int) { return RuntimeErrorCode; }
-  static ReturnType SystemError(std::system_error& ex, int) { return SystemErrorCode; }
+  typedef ReturnType ReturnType;
+  static ReturnType Unknown(int) { return ReturnType::UnknownCode; }
+  static ReturnType Exception(const std::exception&, int) { return ReturnType::ExceptionCode; }
+  static ReturnType Exception(const std::logic_error&, int) { return ReturnType::LogicErrorCode; }
+  static ReturnType Exception(const std::runtime_error&, int) { return ReturnType::RuntimeErrorCode; }
+  static ReturnType Exception(const std::system_error&, int) { return ReturnType::SystemErrorCode; }
 };
 
 template<class X>
-void TrivialReturn(int n, X x)
+void TrivialReturn(ReturnType n, X x)
 {
   ASSERT_NO_THROW(
   {
     try
     {
       throw x;
     }
     catch (...)
     {
       ASSERT_EQ(n, CatchAllReturn<NullHandlersReturn>::Handler(0));
     }
   });
 }
 
 TEST(Exception, TrivialReturnUnknown)
 {
-  TrivialReturn(UnknownCode, 5);
+  TrivialReturn(ReturnType::UnknownCode, 5);
 }
 
 TEST(Exception, TrivialReturnException)
 {
-  TrivialReturn(ExceptionCode, PlainException());
+  TrivialReturn(ReturnType::ExceptionCode, PlainException());
 }
 
 TEST(Exception, TrivialReturnLogicError)
 {
-  TrivialReturn(LogicErrorCode, std::logic_error(""));
+  TrivialReturn(ReturnType::LogicErrorCode, std::logic_error(""));
 }
 
 TEST(Exception, TrivialReturnRuntimeError)
 {
-  TrivialReturn(RuntimeErrorCode, std::runtime_error(""));
+  TrivialReturn(ReturnType::RuntimeErrorCode, std::runtime_error(""));
 }
 
 TEST(Exception, TrivialReturnSystemError)
 {
-  TrivialReturn(SystemErrorCode, std::system_error(std::error_code()));
-}
-
-/*
- * VS 2012 supports thread_local semantics for POD only, not arbitrary types.
- * That's good enough for now.
- * Remove the definition when VS matures.
- */
-#define thread_local __declspec(thread)
-
-/*
- * The sub-handlers are purely static functions, 
- *   so getting them to return something unique for testing has possible race conditions.
- * We're using a thread-local variable as a return code from the simple handlers,
- *    which ensures that even a multi-threaded test runner will work here.
- */
-thread_local int SimpleResult;
-thread_local int SimpleExpected;
+  TrivialReturn(ReturnType::SystemErrorCode, std::system_error(std::error_code()));
+}
+
+class Touchable
+{
+public:
+  Touchable() : m_isTouched(false){}
+  bool IsTouched() const
+  {
+    return m_isTouched;
+  }
+  void Touch()
+  {
+    m_isTouched = true;
+  }
+private:
+  // In the tests we use `Touchable&` as the type for UserData, so let's make
+  // it uncopyable to be sure that it's not copied somewhere by accident.
+  Touchable(const Touchable&);
+  void operator=(const Touchable&);
+private:
+  bool m_isTouched;
+};
 
 /*
  * The simple tests ensure that the flow of control arrives in the correct subhandler.
  */
-template<class X, class H>
-void SimpleVoid(X x, H h)
-{
-  SimpleResult = 0;
-  SimpleExpected = std::rand();
-  if (SimpleExpected == 0) { SimpleExpected = 1; }
+template<typename H, class X>
+void SimpleVoid(X x)
+{
+  Touchable userData;
   ASSERT_NO_THROW(
   {
     try
     {
       throw x;
     }
     catch (...)
     {
-      CatchAllVoid<H>::Handler(0);
+      CatchAllVoid<H>::Handler<Touchable&>(userData);
     }
   });
-  EXPECT_EQ(SimpleExpected, SimpleResult);
+  EXPECT_TRUE(userData.IsTouched());
 }
 
 /*
  * The base handler class for the simple tests fails every execution path.
  * Each specific test redefines a single one of the handler functions that it uses.
  */
 class SimpleHandlersBase
 {
 public:
-  static void Unknown(int) { FAIL() << "Unexpected exception of unknown type"; }
-  static void Exception(std::exception& ex, int) { FAIL() << "Unexpected std::exception"; }
-  static void LogicError(std::logic_error& ex, int) { FAIL() << "Unexpected std::logic_error"; }
-  static void RuntimeError(std::runtime_error& ex, int) { FAIL() << "Unexpected std::runtime_error"; }
-  static void SystemError(std::system_error& ex, int) { FAIL() << "Unexpected std::system_error"; };
-protected:
-  static void Ping() { SimpleResult = SimpleExpected; }
+  typedef Touchable& UserData;
+  SimpleHandlersBase(){}
+  static void Unknown(UserData) { FAIL() << "Unexpected exception of unknown type"; }
+  static void Exception(const std::exception&, UserData) { FAIL() << "Unexpected std::exception"; }
+  static void Exception(const std::logic_error&, UserData) { FAIL() << "Unexpected std::logic_error"; }

[sergei, 2015/04/01 07:16:02]

JIC, actually, these three methods as well as the same methods of
SimpleHandlersReturnBase can be also removed, however it may be good to keep the
for the sake of demonstration of the overriding of them.

+  static void Exception(const std::runtime_error&, UserData) { FAIL() << "Unexpected std::runtime_error"; }
+  static void Exception(const std::system_error&, UserData) { FAIL() << "Unexpected std::system_error"; };
 };
 
 TEST(Exception, SimpleVoidUnknown)
 {
   struct Handler :
     public SimpleHandlersBase
   {
-    static void Unknown(int) { Ping(); }
-  };
-  SimpleVoid(5, Handler());
+    static void Unknown(UserData h) { h.Touch(); }
+  };
+  SimpleVoid<Handler>(5);
 }
 
 TEST(Exception, SimpleVoidException)
 {
   struct Handler :
     public SimpleHandlersBase
   {
-    static void Exception(std::exception& ex, int) { Ping(); }
-  };
-  SimpleVoid(PlainException(), Handler());
+    static void Exception(const std::exception&, UserData h) { h.Touch(); }
+  };
+  SimpleVoid<Handler>(PlainException());
 }
 
 TEST(Exception, SimpleVoidLogicError)
 {
   struct Handler :
     public SimpleHandlersBase
   {
-    static void LogicError(std::logic_error& ex, int) { Ping(); }
-  };
-  SimpleVoid(std::logic_error(""), Handler());
+    static void Exception(const std::logic_error&, UserData h) { h.Touch(); }
+    using SimpleHandlersBase::Exception;
+  };
+  SimpleVoid<Handler>(std::logic_error(""));
 }
 
 TEST(Exception, SimpleVoidRuntimeError)
 {
   struct Handler :
     public SimpleHandlersBase
   {
-    static void RuntimeError(std::runtime_error& ex, int) { Ping(); }
-  };
-  SimpleVoid(std::runtime_error(""), Handler());
+    static void Exception(const std::runtime_error&, UserData h) { h.Touch(); }
+    using SimpleHandlersBase::Exception;
+  };
+  SimpleVoid<Handler>(std::runtime_error(""));
 }
 
 TEST(Exception, SimpleVoidSystemError)
 {
   struct Handler :
     public SimpleHandlersBase
   {
-    static void SystemError(std::system_error& ex, int) { Ping(); }
-  };
-  SimpleVoid(std::system_error(std::error_code()), Handler());
-}
-
-template<class X, class H>
-void SimpleReturn(int n, X x, H h)
-{
-  SimpleResult = 0;
-  SimpleExpected = rand();
-  if (SimpleExpected == 0) { SimpleExpected = 1; }
+    static void Exception(const std::system_error&, UserData h) { h.Touch(); }
+    using SimpleHandlersBase::Exception;
+  };
+  SimpleVoid<Handler>(std::system_error(std::error_code()));
+}
+
+template<class H, class X>
+void SimpleReturn(ReturnType n, X x)
+{
+  Touchable userData;
   ASSERT_NO_THROW(
   {
     try
     {
       throw x;
     }
     catch (...)
     {
-      EXPECT_EQ(n, CatchAllReturn<H>::Handler(0));
+      EXPECT_EQ(n, CatchAllReturn<H>::Handler<Touchable&>(userData));
     }
   });
-  EXPECT_EQ(SimpleExpected, SimpleResult);
+  EXPECT_TRUE(userData.IsTouched());
 }
 
 /*
  * The base handlers class fails every execution path.
  */
 class SimpleHandlersReturnBase
 {
 public:
-  typedef int ReturnType;
-  static ReturnType Unknown(int) { ADD_FAILURE() << "Unexpected exception of unknown type"; return InvalidCode; }
-  static ReturnType Exception(std::exception& ex, int) { ADD_FAILURE() << "Unexpected std::exception"; return InvalidCode; }
-  static ReturnType LogicError(std::logic_error& ex, int) { ADD_FAILURE() << "Unexpected std::logic_error"; return InvalidCode; }
-  static ReturnType RuntimeError(std::runtime_error& ex, int) { ADD_FAILURE() << "Unexpected std::runtime_error"; return InvalidCode; }
-  static ReturnType SystemError(std::system_error& ex, int) { ADD_FAILURE() << "Unexpected std::system_error"; return InvalidCode; }
-protected:
-  static void Ping() { SimpleResult = SimpleExpected; }
+  typedef ReturnType ReturnType;
+  typedef Touchable& UserData;
+  static ReturnType Unknown(UserData) { ADD_FAILURE() << "Unexpected exception of unknown type"; return ReturnType::InvalidCode; }
+  static ReturnType Exception(const std::exception&, UserData) { ADD_FAILURE() << "Unexpected std::exception"; return ReturnType::InvalidCode; }
+  static ReturnType Exception(const std::logic_error&, UserData) { ADD_FAILURE() << "Unexpected std::logic_error"; return ReturnType::InvalidCode; }
+  static ReturnType Exception(const std::runtime_error&, UserData) { ADD_FAILURE() << "Unexpected std::runtime_error"; return ReturnType::InvalidCode; }
+  static ReturnType Exception(const std::system_error&, UserData) { ADD_FAILURE() << "Unexpected std::system_error"; return ReturnType::InvalidCode; }
 };
 
 TEST(Exception, SimpleReturnUnknown)
 {
   struct Handler :
     public SimpleHandlersReturnBase
   {
-    static int Unknown(int) { Ping(); return UnknownCode; }
-  };
-  SimpleReturn(UnknownCode, 5, Handler());
+    static ReturnType Unknown(UserData h) { h.Touch(); return ReturnType::UnknownCode; }
+    using SimpleHandlersReturnBase::Exception;
+  };
+  SimpleReturn<Handler>(ReturnType::UnknownCode, 5);
 }
 
 TEST(Exception, SimpleReturnException)
 {
   struct Handler :
     public SimpleHandlersReturnBase
   {
-    static int Exception(std::exception& ex, int) { Ping(); return ExceptionCode; }
-  };
-  SimpleReturn(ExceptionCode, PlainException(), Handler());
+    static ReturnType Exception(const std::exception&, UserData h) { h.Touch(); return ReturnType::ExceptionCode; }
+    using SimpleHandlersReturnBase::Exception;
+  };
+  SimpleReturn<Handler>(ReturnType::ExceptionCode, PlainException());
 }
 
 TEST(Exception, SimpleReturnLogicError)
 {
   struct Handler :
     public SimpleHandlersReturnBase
   {
-    static int LogicError(std::logic_error& ex, int) { Ping(); return LogicErrorCode; }
-  };
-  SimpleReturn(LogicErrorCode, std::logic_error(""), Handler());
+    static ReturnType Exception(const std::logic_error&, UserData h) { h.Touch(); return ReturnType::LogicErrorCode; }
+    using SimpleHandlersReturnBase::Exception;
+  };
+  SimpleReturn<Handler>(ReturnType::LogicErrorCode, std::logic_error(""));
 }
 
 TEST(Exception, SimpleReturnRuntimeError)
 {
   struct Handler :
     public SimpleHandlersReturnBase
   {
-    static int RuntimeError(std::runtime_error& ex, int) { Ping(); return RuntimeErrorCode; }
-  };
-  SimpleReturn(RuntimeErrorCode, std::runtime_error(""), Handler());
+    static ReturnType Exception(const std::runtime_error&, UserData h) { h.Touch(); return ReturnType::RuntimeErrorCode; }
+    using SimpleHandlersReturnBase::Exception;
+  };
+  SimpleReturn<Handler>(ReturnType::RuntimeErrorCode, std::runtime_error(""));
 }
 
 TEST(Exception, SimpleReturnSystemError)
 {
   struct Handler :
     public SimpleHandlersReturnBase
   {
-    static int SystemError(std::system_error& ex, int) { Ping(); return SystemErrorCode; }
-  };
-  SimpleReturn(SystemErrorCode, std::system_error(std::error_code()), Handler());
-}
-
+    static ReturnType Exception(const std::system_error&, UserData h) { h.Touch(); return ReturnType::SystemErrorCode; }
+    using SimpleHandlersReturnBase::Exception;
+  };
+  SimpleReturn<Handler>(ReturnType::SystemErrorCode, std::system_error(std::error_code()));
+}