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   int truncate_float(float x) { return (int)x; }
 192   long truncate_double(double x) { return (long)x; }
 193
 194   struct do_truncate_float_t
 195   {
 196     do_truncate_float_t()
 197     {
 198       ++live_objects;
 199     }
 200
 201     do_truncate_float_t(const do_truncate_float_t&)
 202     {
 203       ++live_objects;
 204     }
 205
 206     ~do_truncate_float_t()
 207     {
 208       --live_objects;
 209     }
 210
 211     int operator()(float x) { return (int)x; }
 212
 213     static int live_objects;
 214   };
 215
 216   int do_truncate_float_t::live_objects = 0;
 217
 218   struct do_truncate_double_t
 219   {
 220     do_truncate_double_t()
 221     {
 222      ++live_objects;
 223     }
 224
 225     do_truncate_double_t(const do_truncate_double_t&)
 226     {
 227       ++live_objects;
 228     }
 229
 230     ~do_truncate_double_t()
 231     {
 232       --live_objects;
 233     }
 234
 235     long operator()(double x) { return (long)x; }
 236
 237     static int live_objects;
 238   };
 239
 240   int do_truncate_double_t::live_objects = 0;
 241
 242   struct X
 243   {
 244     int bar;
 245
 246     int foo()                   { return 1; }
 247     int foo_c() const           { return 2; }
 248     int foo_v()  volatile       { return 3; }
 249     int foo_cv() const volatile { return 4; }
 250   };
 251
 252   // For use in 8_c_compatibility.
 253   template<typename R, typename T>
 254     typename __gnu_cxx::__enable_if<std::__are_same<R, T>::__value,
 255                                     bool>::__type
 256     check_ret_type(T)
 257     { return true; }
 258
 259 } // namespace __gnu_test
 260
 261 #endif // _GLIBCXX_TESTSUITE_TR1_H