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
44namespace __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
168