libstdc++-v3/testsuite/util/testsuite_api.h

   1 // -*- C++ -*-
   2 // Exception testing utils for the C++ library testsuite.
   3 //
   4 // Copyright (C) 2007, 2008 Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 2, or (at your option)
  10 // any later version.
  11 //
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING.  If not, write to the Free
  19 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  20 // USA.
  21 //
  22 // As a special exception, you may use this file as part of a free software
  23 // library without restriction.  Specifically, if other files instantiate
  24 // templates or use macros or inline functions from this file, or you compile
  25 // this file and link it with other files to produce an executable, this
  26 // file does not by itself cause the resulting executable to be covered by
  27 // the GNU General Public License.  This exception does not however
  28 // invalidate any other reasons why the executable file might be covered by
  29 // the GNU General Public License.
  30
  31 #include <exception>
  32 #include <testsuite_hooks.h>
  33
  34 #ifndef _TESTSUITE_API
  35 #define _TESTSUITE_API 1
  36
  37 namespace __gnu_test
  38 {
  39   // Checks for virtual public derivation in exception classes.
  40   // See:
  41   // http://www.boost.org/more/error_handling.html
  42   struct bad_non_virtual : virtual public std::exception { };
  43
  44   template<typename Exception, bool DefaultCons>
  45     struct diamond_derivation_base;
  46
  47   template<typename Exception>
  48     struct diamond_derivation_base<Exception, true>
  49     {
  50       struct diamond_derivation_error
  51       : bad_non_virtual, Exception
  52       {
  53         diamond_derivation_error()
  54         : bad_non_virtual(), Exception() { }
  55       };
  56     };
  57
  58   template<typename Exception>
  59     struct diamond_derivation_base<Exception, false>
  60     {
  61       struct diamond_derivation_error
  62       : bad_non_virtual, Exception
  63       {
  64         diamond_derivation_error()
  65         : bad_non_virtual(), Exception("construct diamond") { }
  66       };
  67     };
  68
  69   template<typename Exception, bool DefaultCons>
  70     struct diamond_derivation
  71     : diamond_derivation_base<Exception, DefaultCons>
  72     {
  73       typedef diamond_derivation_base<Exception, DefaultCons> base_type;
  74       typedef typename base_type::diamond_derivation_error error_type;
  75
  76       // NB: In the libstdc++-v3 testsuite, all the standard exception
  77       // classes (+ a couple of extensions) are checked:  since they
  78       // all derive *non* virtually from std::exception, the expected
  79       // behavior is ambiguity.
  80       static void test()
  81       {
  82         bool test __attribute__((unused)) = true;
  83         try
  84           { throw error_type(); }
  85         catch (std::exception const&)
  86           { VERIFY( false ); }
  87         catch (...)
  88           { VERIFY( true ); }
  89       }
  90     };
  91
  92   // Testing type requirements for template arguments.
  93   struct NonDefaultConstructible
  94   {
  95     NonDefaultConstructible(int) { }
  96     NonDefaultConstructible(const NonDefaultConstructible&) { }
  97
  98 #ifdef __GXX_EXPERIMENTAL_CXX0X__
  99     // For std::iota.
 100     NonDefaultConstructible&
 101     operator++()
 102     { return *this; }
 103 #endif
 104   };
 105
 106   // See: 20.1.1 Template argument requirements.
 107   inline bool
 108   operator==(const NonDefaultConstructible&, const NonDefaultConstructible&)
 109   { return false; }
 110
 111   inline bool
 112   operator<(const NonDefaultConstructible&, const NonDefaultConstructible&)
 113   { return false; }
 114
 115   // For 26 numeric algorithms requirements, need addable,
 116   // subtractable, multiplicable.
 117   inline NonDefaultConstructible
 118   operator+(const NonDefaultConstructible& lhs,
 119             const NonDefaultConstructible& rhs)
 120   { return NonDefaultConstructible(1); }
 121
 122   inline NonDefaultConstructible
 123   operator-(const NonDefaultConstructible& lhs,
 124             const NonDefaultConstructible& rhs)
 125   { return NonDefaultConstructible(1); }
 126
 127   inline NonDefaultConstructible
 128   operator*(const NonDefaultConstructible& lhs,
 129             const NonDefaultConstructible& rhs)
 130   { return NonDefaultConstructible(1); }
 131
 132   // Like unary_function, but takes no argument. (ie, void).
 133   // Used for generator template parameter.
 134   template<typename _Result>
 135     struct void_function
 136     {
 137       typedef _Result result_type;
 138
 139       result_type
 140       operator()() const
 141       { return result_type(); }
 142     };
 143
 144   template<>
 145     struct void_function<NonDefaultConstructible>
 146     {
 147       typedef NonDefaultConstructible result_type;
 148
 149       result_type
 150       operator()() const
 151       { return result_type(2); }
 152     };
 153
 154 }
 155 #endif