OSDN Git Service

1970ea09b75e071d472b6505724fb02d114588cf
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / testsuite / testsuite_hooks.cc
1 // -*- C++ -*-
2 // Utility subroutines for the C++ library testsuite. 
3 //
4 // Copyright (C) 2002, 2003 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 2, 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 COPYING.  If not, write to the Free
19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 // USA.
21 //
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction.  Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License.  This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 #include <testsuite_hooks.h>
32
33 #ifdef _GLIBCPP_MEM_LIMITS
34 #include <unistd.h>
35 #include <sys/time.h>
36 #include <sys/resource.h>
37 #endif
38 #include <list>
39 #include <string>
40 #include <stdexcept>
41 #include <clocale>
42 #include <locale>
43 #include <cxxabi.h>
44
45 namespace __gnu_cxx_test
46 {
47 #ifdef _GLIBCPP_MEM_LIMITS
48   void 
49   set_memory_limits(float size)
50   {
51     struct rlimit r;
52     // Cater to the absence of rlim_t.
53     __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur))(size * 1048576);
54
55     // Heap size, seems to be common.
56 #if _GLIBCPP_HAVE_MEMLIMIT_DATA
57     getrlimit(RLIMIT_DATA, &r);
58     r.rlim_cur = limit;
59     setrlimit(RLIMIT_DATA, &r);
60 #endif
61
62     // Resident set size.
63 #if _GLIBCPP_HAVE_MEMLIMIT_RSS
64     getrlimit(RLIMIT_RSS, &r);
65     r.rlim_cur = limit;
66     setrlimit(RLIMIT_RSS, &r);
67 #endif
68
69     // Mapped memory (brk + mmap).
70 #if _GLIBCPP_HAVE_MEMLIMIT_VMEM
71     getrlimit(RLIMIT_VMEM, &r);
72     r.rlim_cur = limit;
73     setrlimit(RLIMIT_VMEM, &r);
74 #endif
75
76     // Virtual memory.
77 #if _GLIBCPP_HAVE_MEMLIMIT_AS
78     getrlimit(RLIMIT_AS, &r);
79     r.rlim_cur = limit;
80     setrlimit(RLIMIT_AS, &r);
81 #endif
82   }
83
84 #else
85   void
86   set_memory_limits(float) { }
87 #endif 
88
89
90   void 
91   verify_demangle(const char* mangled, const char* wanted)
92   {
93     int status = 0;
94     const char* s = abi::__cxa_demangle(mangled, 0, 0, &status);
95     if (!s)
96       {
97         switch (status)
98           {
99           case 0:
100             s = "error code = 0: success";
101             break;
102           case -1:
103             s = "error code = -1: memory allocation failure";
104             break;
105           case -2:
106             s = "error code = -2: invalid mangled name";
107             break;
108           case -3:
109             s = "error code = -3: invalid arguments";
110             break;
111           default:
112             s = "error code unknown - who knows what happened";
113           }
114       }
115
116     std::string w(wanted);
117     if (w != s)
118       throw std::runtime_error(s);
119   }
120
121   
122   // Useful exceptions.
123   class locale_data : public std::runtime_error 
124   {
125   public:
126     explicit 
127     locale_data(const std::string&  __arg) : runtime_error(__arg) { }
128   };
129
130   class environment_variable: public std::runtime_error 
131   {
132   public:
133     explicit 
134     environment_variable(const std::string&  __arg) : runtime_error(__arg) { }
135   };
136
137   class not_found : public std::runtime_error 
138   {
139   public:
140     explicit 
141     not_found(const std::string&  __arg) : runtime_error(__arg) { }
142   };
143
144   void 
145   run_tests_wrapped_locale(const char* name, const func_callback& l)
146   {
147     using namespace std;
148     bool test = true;
149     
150     // Set the global locale. 
151     try
152       {
153         locale loc_name(name);
154         locale orig = locale::global(loc_name);
155       }
156     catch (std::runtime_error& ex)
157       {
158         if (std::strstr (ex.what(), "unhandled name in generic implementation"))
159           return;
160         else if (std::strstr (ex.what(), "unknown name"))
161           return;
162         else
163           throw;
164       }
165
166     const char* res = setlocale(LC_ALL, name);
167     if (res != NULL)
168       {
169         string preLC_ALL = res;
170         for (func_callback::const_iterator i = l.begin(); i != l.end(); ++i)
171           (*i)();
172         string postLC_ALL= setlocale(LC_ALL, NULL);
173         VERIFY( preLC_ALL == postLC_ALL );
174       }
175     else
176       throw environment_variable(string("LC_ALL for") + string(name));
177   }
178   
179   void 
180   run_tests_wrapped_env(const char* name, const char* env,
181                         const func_callback& l)
182   {
183     using namespace std;
184     bool test = true;
185     
186 #ifdef _GLIBCPP_HAVE_SETENV 
187     // Set the global locale. 
188     try
189       {
190         locale loc_name(name);
191         locale orig = locale::global(loc_name);
192       }
193     catch (std::runtime_error& ex)
194       {
195         if (std::strstr (ex.what(), "unhandled name in generic implementation"))
196           return;
197         else if (std::strstr (ex.what(), "unknown name"))
198           return;
199         else
200           throw;
201       }
202     // Set environment variable env to value in name. 
203     const char* oldENV = getenv(env);
204     if (!setenv(env, name, 1))
205       {
206         for (func_callback::const_iterator i = l.begin(); i != l.end(); ++i)
207           (*i)();
208         setenv(env, oldENV ? oldENV : "", 1);
209       }
210     else
211       throw environment_variable(string(env) + string(" to ") + string(name));
212 #endif
213   }
214
215   void 
216   run_test_wrapped_generic_locale_exception_catcher(const test_func f)
217   {
218     try
219       {
220         f();
221       }
222     catch (std::runtime_error& ex)
223       {
224         if (std::strstr (ex.what(), "unhandled name in generic implementation"))
225           return;
226         else if (std::strstr (ex.what(), "unknown name"))
227           return;
228         else
229           throw;
230       }
231   }
232
233   counter::size_type  counter::count = 0;
234   unsigned int copy_constructor::count_ = 0;
235   unsigned int copy_constructor::throw_on_ = 0;
236   unsigned int assignment_operator::count_ = 0;
237   unsigned int assignment_operator::throw_on_ = 0;
238   unsigned int destructor::_M_count = 0;
239   int copy_tracker::next_id_ = 0;
240 }; // namespace __cxx_test