// -*- C++ -*- // Exception testing utils for the C++ library testsuite. // // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option) // any later version. // // This library 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 this library; see the file COPYING3. If not see // . // #include #include #ifndef _TESTSUITE_API #define _TESTSUITE_API 1 namespace __gnu_test { // Checks for virtual public derivation in exception classes. // See: // http://www.boost.org/more/error_handling.html struct bad_non_virtual : virtual public std::exception { }; template struct diamond_derivation_base; template struct diamond_derivation_base { struct diamond_derivation_error : bad_non_virtual, Exception { diamond_derivation_error() : bad_non_virtual(), Exception() { } }; }; template struct diamond_derivation_base { struct diamond_derivation_error : bad_non_virtual, Exception { diamond_derivation_error() : bad_non_virtual(), Exception("construct diamond") { } }; }; template struct diamond_derivation : diamond_derivation_base { typedef diamond_derivation_base base_type; typedef typename base_type::diamond_derivation_error error_type; // NB: In the libstdc++-v3 testsuite, all the standard exception // classes (+ a couple of extensions) are checked: since they // all derive *non* virtually from std::exception, the expected // behavior is ambiguity. static void test() { try { throw error_type(); } catch (std::exception const&) { VERIFY( false ); } catch (...) { VERIFY( true ); } } }; // Testing type requirements for template arguments. struct NonDefaultConstructible { NonDefaultConstructible(int) { } NonDefaultConstructible(const NonDefaultConstructible&) { } #if __cplusplus >= 201103L // For std::iota. NonDefaultConstructible& operator++() { return *this; } #endif }; // See: 20.1.1 Template argument requirements. inline bool operator==(const NonDefaultConstructible&, const NonDefaultConstructible&) { return false; } inline bool operator<(const NonDefaultConstructible&, const NonDefaultConstructible&) { return false; } // For 23 unordered_* requirements. struct NonDefaultConstructible_hash { std::size_t operator()(NonDefaultConstructible) const { return 1; } }; // For 26 numeric algorithms requirements, need addable, // subtractable, multiplicable. inline NonDefaultConstructible operator+(const NonDefaultConstructible& lhs, const NonDefaultConstructible& rhs) { return NonDefaultConstructible(1); } inline NonDefaultConstructible operator-(const NonDefaultConstructible& lhs, const NonDefaultConstructible& rhs) { return NonDefaultConstructible(1); } inline NonDefaultConstructible operator*(const NonDefaultConstructible& lhs, const NonDefaultConstructible& rhs) { return NonDefaultConstructible(1); } // Like unary_function, but takes no argument. (ie, void). // Used for generator template parameter. template struct void_function { typedef _Result result_type; result_type operator()() const { return result_type(); } }; template<> struct void_function { typedef NonDefaultConstructible result_type; result_type operator()() const { return result_type(2); } }; // For std::addressof, etc. struct OverloadedAddressAux { }; struct OverloadedAddress { OverloadedAddressAux operator&() const { return OverloadedAddressAux(); } }; inline bool operator<(const OverloadedAddress&, const OverloadedAddress&) { return false; } inline bool operator==(const OverloadedAddress&, const OverloadedAddress&) { return false; } struct OverloadedAddress_hash { std::size_t operator()(const OverloadedAddress&) const { return 1; } }; #if __cplusplus >= 201103L struct NonCopyConstructible { NonCopyConstructible() : num(-1) { } NonCopyConstructible(NonCopyConstructible&& other) : num(other.num) { other.num = 0; } NonCopyConstructible(const NonCopyConstructible&) = delete; operator int() { return num; } private: int num; }; #endif } #endif