Issue #1173 - 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <gtest/gtest.h>
-
 #include "../../src/plugin/Exception.h"
-
 #include <stdexcept>
 
 void AssignCurrentException(std::exception_ptr& e)
 {
   e = std::current_exception();
 }
 
 /*
  * This test verifies that std::current_exception works during exception handling generally,
  *   not just in the immediate context of a 'catch' clause.
@@ skipping 92 matching lines @@
 TEST(Exception, TrivialVoidRuntimeError)
 {
   TrivialVoid(std::runtime_error(""));
 }
 
 TEST(Exception, TrivialVoidSystemError)
 {
   TrivialVoid(std::system_error(std::error_code()));
 }
 
-enum ExceptionCode
+enum
 {
   InvalidCode = -1,
   UnknownCode = 1,
   ExceptionCode,
   LogicErrorCode,
   RuntimeErrorCode,
   SystemErrorCode
 };
 
 struct NullHandlersReturn
 {
-  typedef int return_t;
-  static return_t Unknown(int) { return UnknownCode; }
-  static return_t Exception(std::exception& ex, int) { return ExceptionCode; }
-  static return_t LogicError(std::logic_error& ex, int) { return LogicErrorCode; }
-  static return_t RuntimeError(std::runtime_error& ex, int) { return RuntimeErrorCode; }
-  static return_t SystemError(std::system_error& ex, int) { return SystemErrorCode; }
+  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; }
 };
 
 template<class X>
 void TrivialReturn(int n, X x)
 {
   ASSERT_NO_THROW(
   {
     try
     {
       throw x;
@@ skipping 21 matching lines @@
 }
 
 TEST(Exception, TrivialReturnRuntimeError)
 {
   TrivialReturn(RuntimeErrorCode, std::runtime_error(""));
 }
 
 TEST(Exception, TrivialReturnSystemError)
 {
   TrivialReturn(SystemErrorCode, std::system_error(std::error_code()));
-}
-
-/*
- * 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 = rand();
-  if (SimpleExpected == 0) { SimpleExpected = 1; }
-  ASSERT_NO_THROW(
-  {
-    try
-    {
-      throw x;
-    }
-    catch (...)
-    {
-      CatchAllVoid<H>::Handler(0);
-    }
-  });
-  EXPECT_EQ(SimpleExpected, SimpleResult);
 }
 
 /*
  * 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;
+
+/*
+ * 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; }
+  ASSERT_NO_THROW(
+  {
+    try
+    {
+      throw x;
+    }
+    catch (...)
+    {
+      CatchAllVoid<H>::Handler(0);
+    }
+  });
+  EXPECT_EQ(SimpleExpected, SimpleResult);
+}
 
 /*
  * 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"; }
@@ skipping 73 matching lines @@
   });
   EXPECT_EQ(SimpleExpected, SimpleResult);
 }
 
 /*
  * The base handlers class fails every execution path.
  */
 class SimpleHandlersReturnBase
 {
 public:
-  typedef int return_t;
-  static return_t Unknown(int) { ADD_FAILURE() << "Unexpected exception of unknown type"; return InvalidCode; }
-  static return_t Exception(std::exception& ex, int) { ADD_FAILURE() << "Unexpected std::exception"; return InvalidCode; }
-  static return_t LogicError(std::logic_error& ex, int) { ADD_FAILURE() << "Unexpected std::logic_error"; return InvalidCode; }
-  static return_t RuntimeError(std::runtime_error& ex, int) { ADD_FAILURE() << "Unexpected std::runtime_error"; return InvalidCode; }
-  static return_t SystemError(std::system_error& ex, int) { ADD_FAILURE() << "Unexpected std::system_error"; return InvalidCode; }
+  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; }
 };
 
 TEST(Exception, SimpleReturnUnknown)
 {
   struct Handler :
     public SimpleHandlersReturnBase
   {
     static int Unknown(int) { Ping(); return UnknownCode; }
@@ skipping 34 matching lines @@
 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());
 }