1// -*- C++ -*-
2// Testing utilities for the tr1 testsuite.
3//
4// Copyright (C) 2004, 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
19// <http://www.gnu.org/licenses/>.
20//
21
22#ifndef _GLIBCXX_TESTSUITE_TR1_H
23#define _GLIBCXX_TESTSUITE_TR1_H
24
25#include <ext/type_traits.h>
26
27namespace __gnu_test
28{
29  // For tr1/type_traits.
30  template<template<typename> class Category, typename Type>
31    bool
32    test_category(bool value)
33    {
34      bool ret = true;
35      ret &= Category<Type>::value == value;
36      ret &= Category<const Type>::value == value;
37      ret &= Category<volatile Type>::value == value;
38      ret &= Category<const volatile Type>::value == value;
39      ret &= Category<Type>::type::value == value;
40      ret &= Category<const Type>::type::value == value;
41      ret &= Category<volatile Type>::type::value == value;
42      ret &= Category<const volatile Type>::type::value == value;
43      return ret;
44    }
45
46  template<template<typename> class Property, typename Type>
47    bool
48    test_property(typename Property<Type>::value_type value)
49    {
50      bool ret = true;
51      ret &= Property<Type>::value == value;
52      ret &= Property<Type>::type::value == value;
53      return ret;
54    }
55
56  // For testing tr1/type_traits/extent, which has a second template
57  // parameter.
58  template<template<typename, unsigned> class Property,
59           typename Type, unsigned Uint>
60    bool
61    test_property(typename Property<Type, Uint>::value_type value)
62    {
63      bool ret = true;
64      ret &= Property<Type, Uint>::value == value;
65      ret &= Property<Type, Uint>::type::value == value;
66      return ret;
67    }
68
69#ifdef __GXX_EXPERIMENTAL_CXX0X__
70  template<template<typename...> class Property, typename... Types>
71    bool
72    test_property(typename Property<Types...>::value_type value)
73    {
74      bool ret = true;
75      ret &= Property<Types...>::value == value;
76      ret &= Property<Types...>::type::value == value;
77      return ret;
78    }
79#endif
80
81  template<template<typename, typename> class Relationship,
82           typename Type1, typename Type2>
83    bool
84    test_relationship(bool value)
85    {
86      bool ret = true;
87      ret &= Relationship<Type1, Type2>::value == value;
88      ret &= Relationship<Type1, Type2>::type::value == value;
89      return ret;
90    }
91
92  // Test types.
93  class ClassType { };
94  typedef const ClassType           cClassType;
95  typedef volatile ClassType        vClassType;
96  typedef const volatile ClassType  cvClassType;
97
98  class DerivedType : public ClassType { };
99
100  enum EnumType { e0 };
101
102  struct ConvType
103  { operator int() const; };
104
105  class AbstractClass
106  {
107    virtual void rotate(int) = 0;
108  };
109
110  class PolymorphicClass
111  {
112    virtual void rotate(int);
113  };
114
115  class DerivedPolymorphic : public PolymorphicClass { };
116
117  class VirtualDestructorClass
118  {
119    virtual ~VirtualDestructorClass();
120  };
121
122  union UnionType { };
123
124  class IncompleteClass;
125
126  struct ExplicitClass
127  {
128    ExplicitClass(double&);
129    explicit ExplicitClass(int&);
130  };
131
132  struct NType   // neither trivial nor standard-layout
133  {
134    int i;
135    int j;
136    virtual ~NType();
137  };
138
139  struct TType   // trivial but not standard-layout
140  {
141    int i;
142  private:
143    int j;
144  };
145
146  struct SLType  // standard-layout but not trivial
147  {
148    int i;
149    int j;
150    ~SLType();
151  };
152
153  struct PODType // both trivial and standard-layout
154  {
155    int i;
156    int j;
157  };
158
159  int truncate_float(float x) { return (int)x; }
160  long truncate_double(double x) { return (long)x; }
161
162  struct do_truncate_float_t
163  {
164    do_truncate_float_t()
165    {
166      ++live_objects;
167    }
168
169    do_truncate_float_t(const do_truncate_float_t&)
170    {
171      ++live_objects;
172    }
173
174    ~do_truncate_float_t()
175    {
176      --live_objects;
177    }
178
179    int operator()(float x) { return (int)x; }
180
181    static int live_objects;
182  };
183
184  int do_truncate_float_t::live_objects = 0;
185
186  struct do_truncate_double_t
187  {
188    do_truncate_double_t()
189    {
190     ++live_objects;
191    }
192
193    do_truncate_double_t(const do_truncate_double_t&)
194    {
195      ++live_objects;
196    }
197
198    ~do_truncate_double_t()
199    {
200      --live_objects;
201    }
202
203    long operator()(double x) { return (long)x; }
204
205    static int live_objects;
206  };
207
208  int do_truncate_double_t::live_objects = 0;
209
210  struct X
211  {
212    int bar;
213
214    int foo()                   { return 1; }
215    int foo_c() const           { return 2; }
216    int foo_v()  volatile       { return 3; }
217    int foo_cv() const volatile { return 4; }
218  };
219
220  // For use in 8_c_compatibility.
221  template<typename R, typename T>
222    typename __gnu_cxx::__enable_if<std::__are_same<R, T>::__value,
223				    bool>::__type
224    check_ret_type(T)
225    { return true; }
226
227} // namespace __gnu_test
228
229#endif // _GLIBCXX_TESTSUITE_TR1_H
230