diff options
Diffstat (limited to 'libstdc++-v3/testsuite/util/testsuite_api.h')
| -rw-r--r-- | libstdc++-v3/testsuite/util/testsuite_api.h | 197 |
1 files changed, 197 insertions, 0 deletions
diff --git a/libstdc++-v3/testsuite/util/testsuite_api.h b/libstdc++-v3/testsuite/util/testsuite_api.h new file mode 100644 index 000000000..110079040 --- /dev/null +++ b/libstdc++-v3/testsuite/util/testsuite_api.h @@ -0,0 +1,197 @@ +// -*- C++ -*- +// Exception testing utils for the C++ library testsuite. +// +// Copyright (C) 2007, 2008, 2009, 2010 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 +// <http://www.gnu.org/licenses/>. +// + +#include <exception> +#include <testsuite_hooks.h> + +#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<typename Exception, bool DefaultCons> + struct diamond_derivation_base; + + template<typename Exception> + struct diamond_derivation_base<Exception, true> + { + struct diamond_derivation_error + : bad_non_virtual, Exception + { + diamond_derivation_error() + : bad_non_virtual(), Exception() { } + }; + }; + + template<typename Exception> + struct diamond_derivation_base<Exception, false> + { + struct diamond_derivation_error + : bad_non_virtual, Exception + { + diamond_derivation_error() + : bad_non_virtual(), Exception("construct diamond") { } + }; + }; + + template<typename Exception, bool DefaultCons> + struct diamond_derivation + : diamond_derivation_base<Exception, DefaultCons> + { + typedef diamond_derivation_base<Exception, DefaultCons> 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() + { + bool test __attribute__((unused)) = true; + 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&) { } + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // 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<typename _Result> + struct void_function + { + typedef _Result result_type; + + result_type + operator()() const + { return result_type(); } + }; + + template<> + struct void_function<NonDefaultConstructible> + { + 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; } + }; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + 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 |