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

   1 // -*- C++ -*-
   2 // Testing utilities for the tr1 testsuite.
   3 //
   4 // Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010
   5 // Free Software Foundation, Inc.
   6 //
   7 // This file is part of the GNU ISO C++ Library.  This library is free
   8 // software; you can redistribute it and/or modify it under the
   9 // terms of the GNU General Public License as published by the
  10 // Free Software Foundation; either version 3, or (at your option)
  11 // any later version.
  12 //
  13 // This library is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License along
  19 // with this library; see the file COPYING3.  If not see
  20 // <http://www.gnu.org/licenses/>.
  21 //
  22
  23 #ifndef _GLIBCXX_TESTSUITE_TR1_H
  24 #define _GLIBCXX_TESTSUITE_TR1_H
  25
  26 #include <ext/type_traits.h>
  27
  28 namespace __gnu_test
  29 {
  30   // For tr1/type_traits.
  31   template<template<typename> class Category, typename Type>
  32     bool
  33     test_category(bool value)
  34     {
  35       bool ret = true;
  36       ret &= Category<Type>::value == value;
  37       ret &= Category<const Type>::value == value;
  38       ret &= Category<volatile Type>::value == value;
  39       ret &= Category<const volatile Type>::value == value;
  40       ret &= Category<Type>::type::value == value;
  41       ret &= Category<const Type>::type::value == value;
  42       ret &= Category<volatile Type>::type::value == value;
  43       ret &= Category<const volatile Type>::type::value == value;
  44       return ret;
  45     }
  46
  47   template<template<typename> class Property, typename Type>
  48     bool
  49     test_property(typename Property<Type>::value_type value)
  50     {
  51       bool ret = true;
  52       ret &= Property<Type>::value == value;
  53       ret &= Property<Type>::type::value == value;
  54       return ret;
  55     }
  56
  57   // For testing tr1/type_traits/extent, which has a second template
  58   // parameter.
  59   template<template<typename, unsigned> class Property,
  60            typename Type, unsigned Uint>
  61     bool
  62     test_property(typename Property<Type, Uint>::value_type value)
  63     {
  64       bool ret = true;
  65       ret &= Property<Type, Uint>::value == value;
  66       ret &= Property<Type, Uint>::type::value == value;
  67       return ret;
  68     }
  69
  70 #ifdef __GXX_EXPERIMENTAL_CXX0X__
  71   template<template<typename...> class Property, typename... Types>
  72     bool
  73     test_property(typename Property<Types...>::value_type value)
  74     {
  75       bool ret = true;
  76       ret &= Property<Types...>::value == value;
  77       ret &= Property<Types...>::type::value == value;
  78       return ret;
  79     }
  80 #endif
  81
  82   template<template<typename, typename> class Relationship,
  83            typename Type1, typename Type2>
  84     bool
  85     test_relationship(bool value)
  86     {
  87       bool ret = true;
  88       ret &= Relationship<Type1, Type2>::value == value;
  89       ret &= Relationship<Type1, Type2>::type::value == value;
  90       return ret;
  91     }
  92
  93   // Test types.
  94   class ClassType { };
  95   typedef const ClassType           cClassType;
  96   typedef volatile ClassType        vClassType;
  97   typedef const volatile ClassType  cvClassType;
  98
  99   class DerivedType : public ClassType { };
 100
 101   enum EnumType { e0 };
 102
 103   struct ConvType
 104   { operator int() const; };
 105
 106   class AbstractClass
 107   {
 108     virtual void rotate(int) = 0;
 109   };
 110
 111   class PolymorphicClass
 112   {
 113     virtual void rotate(int);
 114   };
 115
 116   class DerivedPolymorphic : public PolymorphicClass { };
 117
 118   class VirtualDestructorClass
 119   {
 120     virtual ~VirtualDestructorClass();
 121   };
 122
 123   union UnionType { };
 124
 125   class IncompleteClass;
 126
 127   struct ExplicitClass
 128   {
 129     ExplicitClass(double&);
 130     explicit ExplicitClass(int&);
 131     ExplicitClass(double&, int&, double&);
 132   };
 133
 134   struct NothrowExplicitClass
 135   {
 136     NothrowExplicitClass(double&) throw();
 137     explicit NothrowExplicitClass(int&) throw();
 138     NothrowExplicitClass(double&, int&, double&) throw();
 139   };
 140
 141   struct ThrowExplicitClass
 142   {
 143     ThrowExplicitClass(double&) throw(int);
 144     explicit ThrowExplicitClass(int&) throw(int);
 145     ThrowExplicitClass(double&, int&, double&) throw(int);
 146   };
 147
 148 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 149   struct NoexceptExplicitClass
 150   {
 151     NoexceptExplicitClass(double&) noexcept(true);
 152     explicit NoexceptExplicitClass(int&) noexcept(true);
 153     NoexceptExplicitClass(double&, int&, double&) noexcept(true);
 154   };
 155
 156   struct ExceptExplicitClass
 157   {
 158     ExceptExplicitClass(double&) noexcept(false);
 159     explicit ExceptExplicitClass(int&) noexcept(false);
 160     ExceptExplicitClass(double&, int&, double&) noexcept(false);
 161   };
 162 #endif
 163
 164   struct NType   // neither trivial nor standard-layout
 165   {
 166     int i;
 167     int j;
 168     virtual ~NType();
 169   };
 170
 171   struct TType   // trivial but not standard-layout
 172   {
 173     int i;
 174   private:
 175     int j;
 176   };
 177
 178   struct SLType  // standard-layout but not trivial
 179   {
 180     int i;
 181     int j;
 182     ~SLType();
 183   };
 184
 185   struct PODType // both trivial and standard-layout
 186   {
 187     int i;
 188     int j;
 189   };
 190
 191 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 192   struct LType // literal type
 193   {
 194     int _M_i;
 195
 196     constexpr LType(int __i) : _M_i(__i) { }
 197   };
 198
 199   struct LTypeDerived : public LType
 200   {
 201     constexpr LTypeDerived(int __i) : LType(__i) { }
 202   };
 203
 204   struct NLType // not literal type
 205   {
 206     int _M_i;
 207
 208     NLType() : _M_i(0) { }
 209
 210     constexpr NLType(int __i) : _M_i(__i) { }
 211
 212     NLType(const NLType& __other) : _M_i(__other._M_i) { }
 213
 214     ~NLType() { _M_i = 0; }
 215   };
 216 #endif
 217
 218   int truncate_float(float x) { return (int)x; }
 219   long truncate_double(double x) { return (long)x; }
 220
 221   struct do_truncate_float_t
 222   {
 223     do_truncate_float_t()
 224     {
 225       ++live_objects;
 226     }
 227
 228     do_truncate_float_t(const do_truncate_float_t&)
 229     {
 230       ++live_objects;
 231     }
 232
 233     ~do_truncate_float_t()
 234     {
 235       --live_objects;
 236     }
 237
 238     int operator()(float x) { return (int)x; }
 239
 240     static int live_objects;
 241   };
 242
 243   int do_truncate_float_t::live_objects = 0;
 244
 245   struct do_truncate_double_t
 246   {
 247     do_truncate_double_t()
 248     {
 249      ++live_objects;
 250     }
 251
 252     do_truncate_double_t(const do_truncate_double_t&)
 253     {
 254       ++live_objects;
 255     }
 256
 257     ~do_truncate_double_t()
 258     {
 259       --live_objects;
 260     }
 261
 262     long operator()(double x) { return (long)x; }
 263
 264     static int live_objects;
 265   };
 266
 267   int do_truncate_double_t::live_objects = 0;
 268
 269   struct X
 270   {
 271     int bar;
 272
 273     int foo()                   { return 1; }
 274     int foo_c() const           { return 2; }
 275     int foo_v()  volatile       { return 3; }
 276     int foo_cv() const volatile { return 4; }
 277   };
 278
 279   // For use in 8_c_compatibility.
 280   template<typename R, typename T>
 281     typename __gnu_cxx::__enable_if<std::__are_same<R, T>::__value,
 282                                     bool>::__type
 283     check_ret_type(T)
 284     { return true; }
 285
 286 } // namespace __gnu_test
 287
 288 #endif // _GLIBCXX_TESTSUITE_TR1_H