diff options
Diffstat (limited to 'libstdc++-v3/testsuite/testsuite_hooks.h')
| -rw-r--r-- | libstdc++-v3/testsuite/testsuite_hooks.h | 345 |
1 files changed, 176 insertions, 169 deletions
diff --git a/libstdc++-v3/testsuite/testsuite_hooks.h b/libstdc++-v3/testsuite/testsuite_hooks.h index 9f89b03a772..cd05443dacd 100644 --- a/libstdc++-v3/testsuite/testsuite_hooks.h +++ b/libstdc++-v3/testsuite/testsuite_hooks.h @@ -1,6 +1,7 @@ -// Utility subroutines for the C++ library testsuite. +// -*- C++ -*- +// Utility subroutines for the C++ library testsuite. // -// Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc. +// Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -34,25 +35,25 @@ // #define(able) assert() behavior for debugging/testing. It may be // a suitable location for other furry woodland creatures as well. // -// 2) __set_testsuite_memlimit() -// __set_testsuite_memlimit() uses setrlimit() to restrict dynamic memory +// 2) set_memory_limits() +// set_memory_limits() uses setrlimit() to restrict dynamic memory // allocation. We provide a default memory limit if none is passed by the -// calling application. The argument to __set_testsuite_memlimit() is the +// calling application. The argument to set_memory_limits() is the // limit in megabytes (a floating-point number). If _GLIBCPP_MEM_LIMITS is // not #defined before including this header, then no limiting is attempted. // -// 3) gnu_counting_struct +// 3) counter // This is a POD with a static data member, gnu_counting_struct::count, // which starts at zero, increments on instance construction, and decrements // on instance destruction. "assert_count(n)" can be called to VERIFY() // that the count equals N. // -// 4) gnu_copy_tracker, from Stephen M. Webb <stephen@bregmasoft.com>. +// 4) copy_tracker, from Stephen M. Webb <stephen@bregmasoft.com>. // A class with nontrivial ctor/dtor that provides the ability to track the // number of copy ctors and dtors, and will throw on demand during copy. // -// 5) gnu_char, gnu_char_traits, abstract character classes and -// char_traits specializations for testing instantiations. +// 5) pod_char, pod_int, , abstract character classes and +// char_traits specializations for testing instantiations. #ifndef _GLIBCPP_TESTSUITE_HOOKS_H #define _GLIBCPP_TESTSUITE_HOOKS_H @@ -60,185 +61,206 @@ #include <bits/c++config.h> #include <bits/functexcept.h> #include <cstddef> - #ifdef DEBUG_ASSERT # include <cassert> # define VERIFY(fn) assert(fn) #else # define VERIFY(fn) test &= (fn) #endif +#include <list> -// Defined in GLIBCPP_CONFIGURE_TESTSUITE. -#ifndef _GLIBCPP_MEM_LIMITS -// Don't do memory limits. -extern void -__set_testsuite_memlimit(float x = 0); +namespace __gnu_cxx_test +{ + // All macros are defined in GLIBCPP_CONFIGURE_TESTSUITE and imported + // from c++config.h + // Set memory limits if possible, if not set to 0. +#ifndef _GLIBCPP_MEM_LIMITS +# define MEMLIMIT_MB 0 #else - -// Do memory limits. -#ifndef MEMLIMIT_MB -#define MEMLIMIT_MB 16.0 +# ifndef MEMLIMIT_MB +# define MEMLIMIT_MB 16.0 +# endif #endif + extern void + set_memory_limits(float __size = MEMLIMIT_MB); -extern void -__set_testsuite_memlimit(float __size = MEMLIMIT_MB); -#endif + // Simple callback structure for variable numbers of tests (all with + // same signature). Assume all unit tests are of the signature + // void test01(); + typedef void (*test_func) (void); + typedef std::list<test_func> func_callback; + // Run select unit tests after setting global locale. + void + run_tests_wrapped_locale(const char*, const func_callback&); -struct gnu_counting_struct -{ + // Run select unit tests after setting environment variables. + void + run_tests_wrapped_env(const char*, const char*, const func_callback&); + + // Test data types. + struct pod_char + { + unsigned char c; + }; + + struct pod_int + { + int i; + }; + + struct pod_unsigned_int + { + unsigned int i; + }; + + struct pod_long + { + unsigned long i; + }; + + struct state + { + unsigned long l; + unsigned long l2; + }; + + // Counting. + struct counter + { // Specifically and glaringly-obviously marked 'signed' so that when // COUNT mistakenly goes negative, we can track the patterns of // deletions more easily. typedef signed int size_type; static size_type count; - gnu_counting_struct() { ++count; } - gnu_counting_struct (const gnu_counting_struct&) { ++count; } - ~gnu_counting_struct() { --count; } -}; - -#define assert_count(n) VERIFY(gnu_counting_struct::count == n) - -// A (static) class for counting copy constructors and possibly throwing an -// exception on a desired count. -class gnu_copy_constructor -{ -public: - static unsigned int - count() - { return count_; } - - static void - mark_call() + counter() { ++count; } + counter (const counter&) { ++count; } + ~counter() { --count; } + }; + +#define assert_count(n) VERIFY(__gnu_cxx_test::counter::count == n) + + // A (static) class for counting copy constructors and possibly throwing an + // exception on a desired count. + class copy_constructor { - count_++; - if (count_ == throw_on_) + public: + static unsigned int + count() { return count_; } + + static void + mark_call() { - __throw_exception_again "copy constructor exception"; + count_++; + if (count_ == throw_on_) + __throw_exception_again "copy constructor exception"; } - } + + static void + reset() + { + count_ = 0; + throw_on_ = 0; + } + + static void + throw_on(unsigned int count) { throw_on_ = count; } - static void - reset() + private: + static unsigned int count_; + static unsigned int throw_on_; + }; + + // A (static) class for counting assignment operator calls and + // possibly throwing an exception on a desired count. + class assignment_operator { - count_ = 0; - throw_on_ = 0; - } - - static void - throw_on(unsigned int count) - { throw_on_ = count; } - -private: - static unsigned int count_; - static unsigned int throw_on_; -}; - -// A (static) class for counting assignment operator calls and possibly -// throwing an exception on a desired count. -class gnu_assignment_operator -{ -public: - static unsigned int - count() - { return count_; } + public: + static unsigned int + count() { return count_; } + + static void + mark_call() + { + count_++; + if (count_ == throw_on_) + __throw_exception_again "assignment operator exception"; + } - static void - mark_call() - { - count_++; - if (count_ == throw_on_) + static void + reset() { - __throw_exception_again "assignment operator exception"; + count_ = 0; + throw_on_ = 0; } - } - static void - reset() - { - count_ = 0; - throw_on_ = 0; - } + static void + throw_on(unsigned int count) { throw_on_ = count; } - static void - throw_on(unsigned int count) - { throw_on_ = count; } + private: + static unsigned int count_; + static unsigned int throw_on_; + }; + + // A (static) class for tracking calls to an object's destructor. + class destructor + { + public: + static unsigned int + count() { return _M_count; } + + static void + mark_call() { _M_count++; } -private: - static unsigned int count_; - static unsigned int throw_on_; -}; + static void + reset() { _M_count = 0; } -// A (static) class for tracking calls to an object's destructor. -class gnu_destructor -{ -public: - static unsigned int - count() - { return count_; } - - static void - mark_call() - { count_++; } - - static void - reset() - { count_ = 0; } - -private: - static unsigned int count_; -}; - -// An class of objects that can be used for validating various behaviours and -// guarantees of containers and algorithms defined in the standard library. -class gnu_copy_tracker -{ + private: + static unsigned int _M_count; + }; + + // An class of objects that can be used for validating various + // behaviours and guarantees of containers and algorithms defined in + // the standard library. + class copy_tracker + { public: - // Creates a copy-tracking object with the given ID number. - // If "throw_on_copy" is set, an exception will be thrown if - // an attempt is made to copy this object. - gnu_copy_tracker(int id = next_id_--, bool throw_on_copy = false) - : id_(id) - , throw_on_copy_(throw_on_copy) - { - } + // Creates a copy-tracking object with the given ID number. If + // "throw_on_copy" is set, an exception will be thrown if an + // attempt is made to copy this object. + copy_tracker(int id = next_id_--, bool throw_on_copy = false) + : id_(id) , throw_on_copy_(throw_on_copy) { } // Copy-constructs the object, marking a call to the copy // constructor and forcing an exception if indicated. - gnu_copy_tracker(const gnu_copy_tracker& rhs) + copy_tracker(const copy_tracker& rhs) : id_(rhs.id()), throw_on_copy_(rhs.throw_on_copy_) { int kkk = throw_on_copy_; if (throw_on_copy_) - { - gnu_copy_constructor::throw_on(gnu_copy_constructor::count() + 1); - } - gnu_copy_constructor::mark_call(); + copy_constructor::throw_on(copy_constructor::count() + 1); + copy_constructor::mark_call(); } // Assigns the value of another object to this one, tracking the // number of times this member function has been called and if the // other object is supposed to throw an exception when it is // copied, well, make it so. - gnu_copy_tracker& - operator=(const gnu_copy_tracker& rhs) + copy_tracker& + operator=(const copy_tracker& rhs) { id_ = rhs.id(); if (rhs.throw_on_copy_) - { - gnu_assignment_operator::throw_on(gnu_assignment_operator::count() - + 1); - } - gnu_assignment_operator::mark_call(); + assignment_operator::throw_on(assignment_operator::count() + 1); + assignment_operator::mark_call(); } - ~gnu_copy_tracker() - { gnu_destructor::mark_call(); } + ~copy_tracker() + { destructor::mark_call(); } int - id() const - { return id_; } + id() const { return id_; } private: int id_; @@ -248,59 +270,44 @@ class gnu_copy_tracker static void reset() { - gnu_copy_constructor::reset(); - gnu_assignment_operator::reset(); - gnu_destructor::reset(); + copy_constructor::reset(); + assignment_operator::reset(); + destructor::reset(); } // for backwards-compatibility static int copyCount() - { return gnu_copy_constructor::count(); } + { return copy_constructor::count(); } // for backwards-compatibility static int dtorCount() - { return gnu_destructor::count(); } + { return destructor::count(); } private: static int next_id_; -}; - -inline bool -operator==(const gnu_copy_tracker& lhs, const gnu_copy_tracker& rhs) -{ return lhs.id() == rhs.id(); } - -struct gnu_char -{ - unsigned long c; -}; + }; -struct gnu_int -{ - unsigned long i; -}; - -struct gnu_state -{ - unsigned long l; - unsigned long l2; -}; + inline bool + operator==(const copy_tracker& lhs, const copy_tracker& rhs) + { return lhs.id() == rhs.id(); } +}; // namespace __gnu_cxx_test -// char_traits specialization namespace std { template<class _CharT> struct char_traits; + // char_traits specialization template<> - struct char_traits<gnu_char> + struct char_traits<__gnu_cxx_test::pod_char> { - typedef gnu_char char_type; - typedef gnu_int int_type; - typedef long pos_type; - typedef unsigned long off_type; - typedef gnu_state state_type; + typedef __gnu_cxx_test::pod_char char_type; + typedef __gnu_cxx_test::pod_int int_type; + typedef long pos_type; + typedef unsigned long off_type; + typedef __gnu_cxx_test::state state_type; static void assign(char_type& __c1, const char_type& __c2); |