exception-error-test.cpp

Go to the documentation of this file.

/*
  ExceptionError(Test)  -  throwing and catching our exception type
 
   Copyright (C)
     2008,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
* *****************************************************************/
 
#include "lib/error.h"
#include "lib/error.hpp"
#include "lib/test/run.hpp"
#include "lib/format-cout.hpp"
#include "lib/util.hpp"
 
#include <exception>
#include <stdexcept>
#include <string>
 
using std::runtime_error;
using std::exception;
using std::string;
 
 
 
namespace lumiera {
  namespace test  {
    
    LUMIERA_ERROR_DEFINE (LIFE_AND_UNIVERSE, "and everything?");
    LUMIERA_ERROR_DECLARE(DERIVED);
    LUMIERA_ERROR_DEFINE (DERIVED, "convoluted exception");
    
    using DerivedError = error::LumieraError<LUMIERA_ERROR_DERIVED, error::External>;
    
    
    /******************************************************/
    class ExceptionError_test : public Test
      {
        typedef ExceptionError_test test;
        
        virtual void
        run (Arg)
          {
            catcher (&test::throwSpecial,  "");
            catcher (&test::throwDerived,  "test-1");
            catcher (&test::throwFatal,    "test-2");
            catcher (&test::throwInvalid,  "test-3");
            catcher (&test::throwExternal, "test-4");
            catcher (&test::throwRuntime,  "test-5");
            catcher (&test::throwExceptn,  "test-6");
            
            catcher (&test::nestedThrower, "test-7");
            catcher (&test::doubleNestedTh,"test-8");
            
            checkErrorFlagPropagation();
            checkRootCauseChaining();
          }
        
        
        
        void throwSpecial (string  ) { throw SpecificError(); }
        void throwDerived (string  ) { throw DerivedError(); }
        void throwFatal   (string _) { throw error::Fatal(_); }
        void throwInvalid (string _) { throw error::Invalid(_); }
        void throwExternal(string _) { throw error::External(_); }
        void throwRuntime (string _) { throw std::runtime_error(_); }
        void throwExceptn (string  ) { throw std::exception(); }
        
        
        void nestedThrower (string msg)
        {
          try { throwExternal(msg); }
          catch (std::exception& e)
            {
              cout << "intermediate handler caught: " << e.what()
                   << "....will rethrow as error::State\n";
              throw error::State (e);
            }
        }
        
        void doubleNestedTh (string msg)
        {
          try { nestedThrower (msg); }
          catch (Error& e)
            {
              cout << "2nd intermediate handler caught: " << e.what()
                   << "....will rethrow as error::Config\n";
              throw error::Config (e);
            }
        }
        
        
        void detectErrorflag (string) { throwOnError(); }
        
        
        void checkErrorFlagPropagation()
        {
          lumiera_error_set(LUMIERA_ERROR_LIFE_AND_UNIVERSE, "what is the answer?");
          CHECK (lumiera_error_peek());
          
          catcher (&test::detectErrorflag);
          CHECK (not lumiera_error_peek());
        }// yet translating that into an exception also clears the error flag
        
        
        void checkRootCauseChaining()
        {
          error::Logic err1;
          error::Config err2(err1);
          error::Config err3(err2);
          Error err4(err1);      // note: copy ctor
          
          std::runtime_error rerr("what a shame");
          error::External err5(rerr);
          Error err6(err5);
          
          CHECK (err2.rootCause() == err1.what());
          CHECK (err3.rootCause() == err1.what());
          CHECK (err4.rootCause() == err1.rootCause()); // mere copy is not a root cause
          
          CHECK (err5.rootCause() == rerr.what());
          CHECK (err6.rootCause() == rerr.what());
        }
        
        
        class SpecificError
          : public error::Invalid
          {
            int value_;
          public:
            SpecificError()
              : error::Invalid{"don't panic", LUMIERA_ERROR_LIFE_AND_UNIVERSE}
              , value_(42)
              { }
            
            int
            revealIt()
              {
                return value_;
              }
          };
        
        
        
        void catcher (void (ExceptionError_test::*funky)(string), string context ="")
        {
          try
            {
              (this->*funky) (context);
            }
          
          catch (SpecificError& e) { cout << "caught: " << e.what() << "..the answer is: " << e.revealIt() << "\n"; }
          catch (error::Logic&  e) { cout << "caught error::Logic: " << e.what() << "\n"; }
          catch (error::Invalid&e) { cout << "caught error::Invalid: " << e.what() << "\n"; }
          catch (Error&         e) { cout << "caught lumiera::Error: " << e.what() << "\n"; }
          catch (runtime_error& e) { cout << "caught std::runtime_error: " << e.what() << "\n"; }
          catch (exception&     e) { cout << "caught std::exception. (unspecific)" << "\n"; }
          catch (...)              { cout << "caught an unknown exception\n"; }
        }
      };
    
    
    
    LAUNCHER (ExceptionError_test, "function common");
    
    
  } // namespace test
    
} // namespace util