OSDN Git Service

2003-01-12 Benjamin Kosnik <bkoz@redhat.com>
[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
44 namespace __gnu_cxx_test
45 {
46 #ifdef _GLIBCPP_MEM_LIMITS
47   void 
48   set_memory_limits(float size)
49   {
50     struct rlimit r;
51     // Cater to the absence of rlim_t.
52     __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur))(size * 1048576);
53
54     // Heap size, seems to be common.
55 #if _GLIBCPP_HAVE_MEMLIMIT_DATA
56     getrlimit(RLIMIT_DATA, &r);
57     r.rlim_cur = limit;
58     setrlimit(RLIMIT_DATA, &r);
59 #endif
60
61     // Resident set size.
62 #if _GLIBCPP_HAVE_MEMLIMIT_RSS
63     getrlimit(RLIMIT_RSS, &r);
64     r.rlim_cur = limit;
65     setrlimit(RLIMIT_RSS, &r);
66 #endif
67
68     // Mapped memory (brk + mmap).
69 #if _GLIBCPP_HAVE_MEMLIMIT_VMEM
70     getrlimit(RLIMIT_VMEM, &r);
71     r.rlim_cur = limit;
72     setrlimit(RLIMIT_VMEM, &r);
73 #endif
74
75     // Virtual memory.
76 #if _GLIBCPP_HAVE_MEMLIMIT_AS
77     getrlimit(RLIMIT_AS, &r);
78     r.rlim_cur = limit;
79     setrlimit(RLIMIT_AS, &r);
80 #endif
81   }
82
83 #else
84   void
85   set_memory_limits(float) { }
86 #endif 
87
88   // Useful exceptions.
89   class locale_data : public std::runtime_error 
90   {
91   public:
92     explicit 
93     locale_data(const std::string&  __arg) : runtime_error(__arg) { }
94   };
95
96   class environment_variable: public std::runtime_error 
97   {
98   public:
99     explicit 
100     environment_variable(const std::string&  __arg) : runtime_error(__arg) { }
101   };
102
103   class not_found : public std::runtime_error 
104   {
105   public:
106     explicit 
107     not_found(const std::string&  __arg) : runtime_error(__arg) { }
108   };
109
110   void 
111   run_tests_wrapped_locale(const char* name, const func_callback& l)
112   {
113     using namespace std;
114     bool test = true;
115     
116     // Set the global locale. 
117     locale loc_name(name);
118     locale orig = locale::global(loc_name);
119     
120     const char* res = setlocale(LC_ALL, name);
121     if (res != NULL)
122       {
123         string preLC_ALL = res;
124         for (func_callback::const_iterator i = l.begin(); i != l.end(); ++i)
125           (*i)();
126         string postLC_ALL= setlocale(LC_ALL, NULL);
127         VERIFY( preLC_ALL == postLC_ALL );
128       }
129     else
130       throw environment_variable(string("LC_ALL for") + string(name));
131   }
132   
133   void 
134   run_tests_wrapped_env(const char* name, const char* env,
135                         const func_callback& l)
136   {
137     using namespace std;
138     bool test = true;
139     
140 #ifdef _GLIBCPP_HAVE_SETENV 
141     // Set the global locale. 
142     locale loc_name(name);
143     locale orig = locale::global(loc_name);
144
145     // Set environment variable env to value in name. 
146     const char* oldENV = getenv(env);
147     if (!setenv(env, name, 1))
148       {
149         for (func_callback::const_iterator i = l.begin(); i != l.end(); ++i)
150           (*i)();
151         setenv(env, oldENV ? oldENV : "", 1);
152       }
153     else
154       throw environment_variable(string(env) + string(" to ") + string(name));
155 #else
156     throw not_found("setenv");
157 #endif
158   }
159
160   counter::size_type  counter::count = 0;
161   unsigned int copy_constructor::count_ = 0;
162   unsigned int copy_constructor::throw_on_ = 0;
163   unsigned int assignment_operator::count_ = 0;
164   unsigned int assignment_operator::throw_on_ = 0;
165   unsigned int destructor::_M_count = 0;
166   int copy_tracker::next_id_ = 0;
167 }; // namespace __cxx_test