+2003-01-12 Benjamin Kosnik <bkoz@redhat.com>
+
+ Renames, namespaces for testsuite utilities.
+ * testsuite/testsuite_hooks.h: Put into namespace __gnu_cxx_test.
+ (gnu_allocator_tracker): Rename to allocation_tracker.
+ (gnu_new_allocator): Rename to tracker_alloc.
+ (__set_testsuite_memlimit): Rename to set_memory_limits.
+ (gnu_assignment_operator): Rename to assignment_operator.
+ (gnu_destructor): Rename to destructor.
+ (gnu_copy_tracker): Rename to copy_tracker.
+ (gnu_char, gnu_int, gnu_long): Rename to pod_char, pod_int, pod_long.
+ (run_tests_wrapped_locale): New.
+ (run_tests_wrapped_env): New.
+ * testsuite/testsuite_hooks.cc: Same.
+ (class locale_data): Add.
+ (class enviornment_variable): Add.
+ (class not_found): Add.
+ * testsuite/testsuite_allocator.h: Same.
+ * testsuite/testsuite_allocator.cc: Same.
+ * testsuite/23_containers/deque_ctor.cc
+ (test_copy_ctor_exception_safety): Change gnu_allocator_tracker to
+ allocation_tracker.
+ Change gnu_new_allocator to tracker_alloc.
+ Change gnu_counting_struct to counter.
+ Change gnu_copy_tracker to copy_tracker.
+ Change gnu_copy_constructor to copy_constructor.
+ Change gnu_assignment_operator to assignment_operator.
+ Inject.
+ * testsuite/23_containers/vector_capacity.cc: Same.
+ * testsuite/23_containers/vector_ctor.cc (test01): Same.
+ * testsuite/23_containers/list_modifiers.cc: Change
+ gnu_copy_tracker to copy_tracker.
+ * testsuite/21_strings/ctor_copy_dtor.cc (main): Change
+ __set_testsuite_memlimit to set_memory_limits.
+ * testsuite/21_strings/insert.cc (main): Same.
+ * testsuite/27_io/filebuf.cc: Change gnu_char to pod_char.
+ * testsuite/27_io/stringstream.cc: Same.
+ * testsuite/27_io/stringbuf.cc: Same.
+ * testsuite/27_io/streambuf.cc: Same.
+ * testsuite/27_io/ostream.cc: Same.
+ * testsuite/27_io/istream.cc: Same.
+ * testsuite/27_io/fstream.cc: Same.
+ * testsuite/lib/libstdc++-v3-dg.exp
+ (libstdc++-v3-list-sourcefiles): Additionally handle files two and
+ three levels deeper in glob patterns.
+
2003-01-11 Phil Edwards <pme@gcc.gnu.org>
* docs/doxygen/tables.html: Finished now.
// 1999-06-04 bkoz
-// Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+// Copyright (C) 1999, 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
int main()
{
- __set_testsuite_memlimit();
+ __gnu_cxx_test::set_memory_limits();
test01();
test02();
test03();
// 1999-06-03 bkoz
-// Copyright (C) 1999 Free Software Foundation, Inc.
+// Copyright (C) 1999, 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
int main()
{
- __set_testsuite_memlimit();
+ __gnu_cxx_test::set_memory_limits();
test01();
test02();
return 0;
// 2001-12-27 pme
//
-// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+// Copyright (C) 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
#include <testsuite_allocator.h>
#include <testsuite_hooks.h>
-typedef std::deque<gnu_counting_struct> gdeque;
+using __gnu_cxx_test::copy_tracker;
+using __gnu_cxx_test::allocation_tracker;
+using __gnu_cxx_test::tracker_alloc;
+using __gnu_cxx_test::copy_constructor;
+using __gnu_cxx_test::assignment_operator;
+using __gnu_cxx_test::counter;
+using __gnu_cxx_test::destructor;
+
+typedef std::deque<counter> gdeque;
bool test = true;
defaultConstructorCheck()
{
// setup
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
// run test
const X u;
copyConstructorCheck()
{
// setup
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
const int copyBaseSize = 17; // arbitrary
X a;
for (int i = 0; i < copyBaseSize; ++i)
a.push_back(i);
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
// assert preconditions
VERIFY(!a.empty());
// assert postconditions
VERIFY(u == a);
- VERIFY(copyBaseSize == gnu_copy_constructor::count());
+ VERIFY(copyBaseSize == copy_constructor::count());
// teardown
}
fillConstructorCheck()
{
// setup
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
const X::size_type n(23);
const X::value_type t(111);
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
// run test
X a(n, t);
// assert postconditions
VERIFY(n == a.size());
- VERIFY(n == gnu_copy_constructor::count());
+ VERIFY(n == copy_constructor::count());
// teardown
}
void
fillConstructorCheck2()
{
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
const int f = 23;
const int l = 111;
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
X a(f, l);
VERIFY(f == a.size());
- VERIFY(f == gnu_copy_constructor::count());
+ VERIFY(f == copy_constructor::count());
}
rangeConstructorCheckForwardIterator()
{
// setup
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
const X::size_type n(726);
X::iterator j = source.end();
X::size_type rangeSize = std::distance(i, j);
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
// test
X a(i, j);
// assert postconditions
VERIFY(rangeSize == a.size());
- VERIFY(gnu_copy_constructor::count() <= rangeSize);
+ VERIFY(copy_constructor::count() <= rangeSize);
}
void
rangeConstructorCheckInputIterator()
{
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
std::istringstream ibuf("1234567890123456789");
std::istream_iterator<char> i(ibuf);
std::istream_iterator<char> j;
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
X a(i, j);
VERIFY(rangeSize == a.size());
- VERIFY(gnu_copy_constructor::count() <= (2 * rangeSize));
+ VERIFY(copy_constructor::count() <= (2 * rangeSize));
}
void
copyAssignmentCheck()
{
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
const X::size_type n(18);
X a(n, t);
X r;
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
r = a;
VERIFY(r == a);
- VERIFY(n == gnu_copy_constructor::count());
+ VERIFY(n == copy_constructor::count());
}
void
fillAssignmentCheck()
{
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
const X::size_type starting_size(10);
const X::value_type t(111);
X a(starting_size, starting_value);
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
// preconditions
VERIFY(starting_size == a.size());
// postconditions
VERIFY(n == a.size());
- VERIFY(n == (gnu_copy_constructor::count() + gnu_assignment_operator::count()));
- VERIFY(starting_size == (gnu_destructor::count() + gnu_assignment_operator::count()));
+ VERIFY(n == (copy_constructor::count() + assignment_operator::count()));
+ VERIFY(starting_size == (destructor::count() + assignment_operator::count()));
}
void
rangeAssignmentCheck()
{
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
const X::size_type source_size(726);
X a(starting_size, starting_value);
VERIFY(starting_size == a.size());
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
a.assign(i, j);
VERIFY(source == a);
- VERIFY(rangeSize == (gnu_copy_constructor::count() + gnu_assignment_operator::count()));
- VERIFY(starting_size == (gnu_destructor::count() + gnu_assignment_operator::count()));
+ VERIFY(rangeSize == (copy_constructor::count() + assignment_operator::count()));
+ VERIFY(starting_size == (destructor::count() + assignment_operator::count()));
}
rangeAssignmentCheckWithException()
{
// setup
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
// test
fillAssignmentCheck2()
{
// setup
- typedef gnu_copy_tracker T;
+ typedef copy_tracker T;
typedef std::deque<T> X;
// test
test_default_ctor_exception_safety()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::deque<T, gnu_new_allocator<T> > X;
+ typedef copy_tracker T;
+ typedef std::deque<T, tracker_alloc<T> > X;
T::reset();
- gnu_copy_constructor::throw_on(3);
- gnu_allocator_tracker::resetCounts();
+ copy_constructor::throw_on(3);
+ allocation_tracker::resetCounts();
// test
try
}
// assert postconditions
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
}
test_copy_ctor_exception_safety()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::deque<T, gnu_new_allocator<T> > X;
+ typedef copy_tracker T;
+ typedef std::deque<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X a(7);
T::reset();
- gnu_copy_constructor::throw_on(3);
+ copy_constructor::throw_on(3);
// test
}
// assert postconditions
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
}
-// Copyright (C) 2001 Free Software Foundation, Inc.
+// Copyright (C) 2001, 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
#include <list>
#include <testsuite_hooks.h>
-typedef gnu_copy_tracker T;
+typedef __gnu_cxx_test::copy_tracker T;
bool test = true;
// 1999-05-07
// bkoz
-// Copyright (C) 1999, 2002 Free Software Foundation, Inc.
+// Copyright (C) 1999, 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
#include <testsuite_allocator.h>
#include <testsuite_hooks.h>
+using __gnu_cxx_test::copy_tracker;
+using __gnu_cxx_test::allocation_tracker;
+using __gnu_cxx_test::tracker_alloc;
+using __gnu_cxx_test::copy_constructor;
+using __gnu_cxx_test::assignment_operator;
+using __gnu_cxx_test::destructor;
+
template<typename T>
struct A { };
void test02()
{
bool test = true;
-
{
std::vector<int> array;
const std::size_t size = array.max_size();
void
test_reserve()
{
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X a(3);
const X::size_type old_size = a.size();
VERIFY(new_capacity <= a.capacity());
// [23.2.4.1 (3)]
VERIFY(old_size == a.size());
- VERIFY(gnu_copy_constructor::count() <= old_size);
- VERIFY(gnu_destructor::count() <= old_size);
+ VERIFY(copy_constructor::count() <= old_size);
+ VERIFY(destructor::count() <= old_size);
}
// check for memory leaks
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
}
// Verifies that reserve() with reallocation offers the strong
void
test_reserve_exception_guarantee()
{
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X a(7);
const X::size_type old_size = a.size();
const X::size_type old_capacity = a.capacity();
const X::size_type new_capacity = old_capacity + 10;
T::reset();
- gnu_copy_constructor::throw_on(3);
+ copy_constructor::throw_on(3);
try
{
}
VERIFY(old_capacity == a.capacity());
- VERIFY(gnu_copy_constructor::count() == gnu_destructor::count()+1);
+ VERIFY(copy_constructor::count() == destructor::count()+1);
}
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
}
int main()
// 1999-06-29 bkoz
-// Copyright (C) 1999-2001, 2002 Free Software Foundation, Inc.
+// Copyright (C) 1999-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
#include <testsuite_allocator.h>
#include <testsuite_hooks.h>
+using __gnu_cxx_test::copy_tracker;
+using __gnu_cxx_test::allocation_tracker;
+using __gnu_cxx_test::tracker_alloc;
+using __gnu_cxx_test::copy_constructor;
+using __gnu_cxx_test::assignment_operator;
+
template<typename T>
struct A { };
void test01()
{
-
// 1
bool test = true;
std::vector< A<B> > vec01;
void
test03()
{
- const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
- const int B[] = {7, 7, 7, 7, 7};
- const int N = sizeof(A) / sizeof(int);
- const int M = sizeof(B) / sizeof(int);
- bool test = true;
-
- std::vector<int> v3(A, A + N);
- VERIFY(std::equal(v3.begin(), v3.end(), A));
-
- std::vector<int> v4(v3.begin(), v3.end());
- VERIFY(std::equal(v4.begin(), v4.end(), A));
-
- std::vector<int> v5(M, 7);
- VERIFY(std::equal(v5.begin(), v5.end(), B));
- VERIFY(std::equal(B, B + M, v5.begin()));
-
+ bool test = true;
+ const int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17};
+ const int B[] = {7, 7, 7, 7, 7};
+ const int N = sizeof(A) / sizeof(int);
+ const int M = sizeof(B) / sizeof(int);
+
+ std::vector<int> v3(A, A + N);
+ VERIFY(std::equal(v3.begin(), v3.end(), A));
+
+ std::vector<int> v4(v3.begin(), v3.end());
+ VERIFY(std::equal(v4.begin(), v4.end(), A));
+
+ std::vector<int> v5(M, 7);
+ VERIFY(std::equal(v5.begin(), v5.end(), B));
+ VERIFY(std::equal(B, B + M, v5.begin()));
+
#ifdef DEBUG_ASSERT
assert(test);
#endif
test_default_ctor_exception_gurantee()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_copy_tracker::reset();
- gnu_copy_constructor::throw_on(3);
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ copy_constructor::throw_on(3);
+ allocation_tracker::resetCounts();
// run test
try
// assert postconditions
VERIFY(("memory leak detected:",
- gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal()));
+ allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal()));
// teardown
}
test_copy_ctor_exception_gurantee()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X a(7);
- gnu_copy_tracker::reset();
- gnu_copy_constructor::throw_on(3);
+ copy_tracker::reset();
+ copy_constructor::throw_on(3);
// run test
try
}
// assert postconditions
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
// operator=()
test_assignment_operator_1()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
X r(9);
X a(r.size() - 2);
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
// preconditions
VERIFY(r.size() > a.size());
// assert postconditions
VERIFY(r == a);
- VERIFY(gnu_allocator_tracker::allocationTotal() == 0);
+ VERIFY(allocation_tracker::allocationTotal() == 0);
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_assignment_operator_2()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
X r(1);
r.reserve(17);
X a(r.size() + 7);
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
// preconditions
VERIFY(r.size() < a.size());
// assert postconditions
VERIFY(r == a);
- VERIFY(gnu_allocator_tracker::allocationTotal() == 0);
+ VERIFY(allocation_tracker::allocationTotal() == 0);
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_assignment_operator_3()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X r(1);
X a(r.capacity() + 7);
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
// preconditions
VERIFY(r.capacity() < a.size());
// assert postconditions
VERIFY(r == a);
}
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_assignment_operator_3_exception_guarantee()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X r(1);
X a(r.capacity() + 7);
- gnu_copy_tracker::reset();
- gnu_copy_constructor::throw_on(3);
+ copy_tracker::reset();
+ copy_constructor::throw_on(3);
// preconditions
VERIFY(r.capacity() < a.size());
}
// assert postconditions
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
// fill assign()
test_fill_assign_1()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
X a(7);
X::size_type old_size = a.size();
X::size_type new_size = old_size - 2;
const T t;
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
// run test
a.assign(new_size, t);
// assert postconditions
VERIFY(a.size() == new_size);
- VERIFY(gnu_allocator_tracker::allocationTotal() == 0);
+ VERIFY(allocation_tracker::allocationTotal() == 0);
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_fill_assign_2()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
X a(7);
a.reserve(11);
X::size_type new_size = old_size + 2;
const T t;
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
// assert preconditions
VERIFY(old_size < new_size);
// assert postconditions
VERIFY(a.size() == new_size);
- VERIFY(gnu_allocator_tracker::allocationTotal() == 0);
+ VERIFY(allocation_tracker::allocationTotal() == 0);
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_fill_assign_3()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X a(7);
X::size_type old_size = a.size();
X::size_type new_size = old_capacity + 4;
const T t;
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
// assert preconditions
VERIFY(new_size > old_capacity);
VERIFY(a.size() == new_size);
}
- VERIFY(gnu_allocator_tracker::allocationTotal() > 0);
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() > 0);
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_fill_assign_3_exception_guarantee()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X a(7);
X::size_type old_size = a.size();
X::size_type new_size = old_capacity + 4;
const T t;
- gnu_copy_tracker::reset();
- gnu_copy_constructor::throw_on(3);
+ copy_tracker::reset();
+ copy_constructor::throw_on(3);
// assert preconditions
VERIFY(new_size > old_capacity);
VERIFY(a.capacity() == old_capacity);
}
- VERIFY(gnu_allocator_tracker::allocationTotal() > 0);
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() > 0);
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_fill_assign_4()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
X a(7);
X::size_type old_size = a.size();
X::size_type new_size = old_size - 2;
X::size_type new_value = 117;
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
// run test
a.assign(new_size, new_value);
// assert postconditions
VERIFY(a.size() == new_size);
- VERIFY(gnu_allocator_tracker::allocationTotal() == 0);
+ VERIFY(allocation_tracker::allocationTotal() == 0);
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
// range assign()
test_range_assign_2()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
X a(7);
X b(3);
X::size_type old_size = a.size();
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
// assert preconditions
VERIFY(b.size() < a.capacity());
// assert postconditions
VERIFY(a.size() == b.size());
VERIFY(a == b);
- VERIFY(gnu_allocator_tracker::allocationTotal() == 0);
+ VERIFY(allocation_tracker::allocationTotal() == 0);
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_range_assign_3()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
X a(7);
a.reserve(a.size() + 7);
X b(a.size() + 3);
X::size_type old_size = a.size();
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
// assert preconditions
VERIFY(a.size() < b.size());
// assert postconditions
VERIFY(a.size() == b.size());
VERIFY(a == b);
- VERIFY(gnu_allocator_tracker::allocationTotal() == 0);
+ VERIFY(allocation_tracker::allocationTotal() == 0);
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_range_assign_4()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X a(7);
X b(a.capacity() + 7);
X::size_type old_size = a.size();
- gnu_copy_tracker::reset();
+ copy_tracker::reset();
// assert preconditions
VERIFY(b.size() > a.capacity());
VERIFY(a.size() == b.size());
VERIFY(a == b);
}
- VERIFY(gnu_allocator_tracker::allocationTotal() > 0);
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() > 0);
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
void
test_range_assign_4_exception_guarantee()
{
// setup
- typedef gnu_copy_tracker T;
- typedef std::vector<T, gnu_new_allocator<T> > X;
+ bool test = true;
+ typedef copy_tracker T;
+ typedef std::vector<T, tracker_alloc<T> > X;
- gnu_allocator_tracker::resetCounts();
+ allocation_tracker::resetCounts();
{
X a(7);
X b(a.capacity() + 7);
X::size_type old_size = a.size();
- gnu_copy_tracker::reset();
- gnu_copy_constructor::throw_on(3);
+ copy_tracker::reset();
+ copy_constructor::throw_on(3);
// assert preconditions
VERIFY(b.size() > a.capacity());
}
// assert postconditions
- VERIFY(gnu_allocator_tracker::allocationTotal() > 0);
- VERIFY(gnu_allocator_tracker::allocationTotal() == gnu_allocator_tracker::deallocationTotal());
+ VERIFY(allocation_tracker::allocationTotal() > 0);
+ VERIFY(allocation_tracker::allocationTotal() == allocation_tracker::deallocationTotal());
// teardown
- gnu_copy_tracker::reset();
- gnu_allocator_tracker::resetCounts();
+ copy_tracker::reset();
+ allocation_tracker::resetCounts();
}
// 1999-01-17 bkoz test functionality of basic_filebuf for char_type == char
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
namespace test
{
using namespace std;
+ using __gnu_cxx_test::pod_char;
typedef short type_t;
template class basic_filebuf<type_t, char_traits<type_t> >;
- template class basic_filebuf<gnu_char, char_traits<gnu_char> >;
+ template class basic_filebuf<pod_char, char_traits<pod_char> >;
} // test
// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
-// Copyright (C) 2002 Free Software Foundation, Inc.
+// Copyright (C) 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
namespace test
{
using namespace std;
+ using __gnu_cxx_test::pod_char;
typedef short type_t;
template class basic_fstream<type_t, char_traits<type_t> >;
- template class basic_fstream<gnu_char, char_traits<gnu_char> >;
+ template class basic_fstream<pod_char, char_traits<pod_char> >;
} // test
int main()
// 1999-09-20 bkoz
-// Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+// Copyright (C) 1999, 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
namespace test
{
using namespace std;
+ using __gnu_cxx_test::pod_char;
typedef short type_t;
template class basic_istream<type_t, char_traits<type_t> >;
- template class basic_istream<gnu_char, char_traits<gnu_char> >;
+ template class basic_istream<pod_char, char_traits<pod_char> >;
} // test
int main()
// 1999-09-20 bkoz
-// Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+// Copyright (C) 1999, 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
namespace test
{
using namespace std;
+ using __gnu_cxx_test::pod_char;
typedef short type_t;
template class basic_ostream<type_t, char_traits<type_t> >;
- template class basic_ostream<gnu_char, char_traits<gnu_char> >;
+ template class basic_ostream<pod_char, char_traits<pod_char> >;
} // test
int main()
// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
-// Copyright (C) 2002 Free Software Foundation, Inc.
+// Copyright (C) 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
namespace test
{
using namespace std;
+ using __gnu_cxx_test::pod_char;
typedef short type_t;
template class basic_streambuf<type_t, char_traits<type_t> >;
- template class basic_streambuf<gnu_char, char_traits<gnu_char> >;
+ template class basic_streambuf<pod_char, char_traits<pod_char> >;
} // test
int main()
// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
-// Copyright (C) 2002 Free Software Foundation, Inc.
+// Copyright (C) 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
namespace test
{
using namespace std;
+ using __gnu_cxx_test::pod_char;
typedef short type_t;
template class basic_stringbuf<type_t, char_traits<type_t> >;
- template class basic_stringbuf<gnu_char, char_traits<gnu_char> >;
+ template class basic_stringbuf<pod_char, char_traits<pod_char> >;
} // test
int main()
// 2002-07-25 Benjamin Kosnik <bkoz@redhat.com>
-// Copyright (C) 2002 Free Software Foundation, Inc.
+// Copyright (C) 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
namespace test
{
using namespace std;
+ using __gnu_cxx_test::pod_char;
typedef short type_t;
template class basic_stringstream<type_t, char_traits<type_t> >;
- template class basic_stringstream<gnu_char, char_traits<gnu_char> >;
+ template class basic_stringstream<pod_char, char_traits<pod_char> >;
} // test
int main()
set f [open $files_file "w"]
set where_we_were [pwd]
cd $srcdir
- foreach s [lsort [glob -nocomplain "{,*/}*/*.cc"]] {
+ foreach s [lsort [glob -nocomplain "*/*.cc" "*/*/*.cc" "{,*/}*/*/*/*.cc" ]] {
lappend sfiles ${srcdir}/${s}
puts $f $s
}
+// -*- C++ -*-
+// Testing allocator for the C++ library testsuite.
//
-// Copyright (C) 2002 Free Software Foundation, Inc.
+// Copyright (C) 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
#include <testsuite_allocator.h>
-gnu_allocator_tracker::size_type gnu_allocator_tracker::allocationTotal_ = 0;
-gnu_allocator_tracker::size_type gnu_allocator_tracker::deallocationTotal_ = 0;
-int gnu_allocator_tracker::constructCount_ = 0;
-int gnu_allocator_tracker::destructCount_ = 0;
+namespace __gnu_cxx_test
+{
+ allocation_tracker::size_type allocation_tracker::allocationTotal_ = 0;
+ allocation_tracker::size_type allocation_tracker::deallocationTotal_ = 0;
+ int allocation_tracker::constructCount_ = 0;
+ int allocation_tracker::destructCount_ = 0;
+}; // namespace __cxx_test
+// -*- C++ -*-
// Testing allocator for the C++ library testsuite.
//
-// Copyright (C) 2002 Free Software Foundation, Inc.
+// Copyright (C) 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
#include <cstddef>
#include <limits>
-class gnu_allocator_tracker
+namespace __gnu_cxx_test
{
- public:
- typedef std::size_t size_type;
-
- static void*
- allocate(size_type blocksize)
+ class allocation_tracker
{
- allocationTotal_ += blocksize;
- return ::operator new(blocksize);
- }
-
- static void
- construct()
- { constructCount_++; }
-
- static void
- destroy()
- { destructCount_++; }
-
- static void
- deallocate(void* p, size_type blocksize)
- {
- ::operator delete(p);
- deallocationTotal_ += blocksize;
- }
-
- static size_type
- allocationTotal()
- { return allocationTotal_; }
+ public:
+ typedef std::size_t size_type;
+
+ static void*
+ allocate(size_type blocksize)
+ {
+ allocationTotal_ += blocksize;
+ return ::operator new(blocksize);
+ }
+
+ static void
+ construct() { constructCount_++; }
- static size_type
- deallocationTotal()
- { return deallocationTotal_; }
+ static void
+ destroy() { destructCount_++; }
- static int
- constructCount()
- { return constructCount_; }
+ static void
+ deallocate(void* p, size_type blocksize)
+ {
+ ::operator delete(p);
+ deallocationTotal_ += blocksize;
+ }
+
+ static size_type
+ allocationTotal() { return allocationTotal_; }
+
+ static size_type
+ deallocationTotal() { return deallocationTotal_; }
+
+ static int
+ constructCount() { return constructCount_; }
- static int
- destructCount()
- { return destructCount_; }
+ static int
+ destructCount() { return destructCount_; }
- static void
- resetCounts()
- {
- allocationTotal_ = 0;
- deallocationTotal_ = 0;
- constructCount_ = 0;
+ static void
+ resetCounts()
+ {
+ allocationTotal_ = 0;
+ deallocationTotal_ = 0;
+ constructCount_ = 0;
destructCount_ = 0;
- }
+ }
private:
- static size_type allocationTotal_;
- static size_type deallocationTotal_;
- static int constructCount_;
- static int destructCount_;
-};
-
-// A simple basic allocator that just forwards to the
-// gnu_allocator_tracker to fulfill memory requests. This class is
-// templated on the target object type, but gnu_allocator_tracker
-// isn't.
-template<class T>
- class gnu_new_allocator
+ static size_type allocationTotal_;
+ static size_type deallocationTotal_;
+ static int constructCount_;
+ static int destructCount_;
+ };
+
+ // A simple basic allocator that just forwards to the
+ // allocation_tracker to fulfill memory requests. This class is
+ // templated on the target object type, but tracker isn't.
+ template<class T>
+ class tracker_alloc
{
public:
typedef T value_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
- template<class U> struct rebind { typedef gnu_new_allocator<U> other; };
+ template<class U> struct rebind { typedef tracker_alloc<U> other; };
pointer
address(reference value) const
address(const_reference value) const
{ return &value; }
- gnu_new_allocator() throw()
+ tracker_alloc() throw()
{ }
- gnu_new_allocator(const gnu_new_allocator&) throw()
+ tracker_alloc(const tracker_alloc&) throw()
{ }
template<class U>
- gnu_new_allocator(const gnu_new_allocator<U>&) throw()
+ tracker_alloc(const tracker_alloc<U>&) throw()
{ }
- ~gnu_new_allocator() throw()
+ ~tracker_alloc() throw()
{ }
size_type
{ return std::numeric_limits<std::size_t>::max() / sizeof(T); }
pointer
- allocate(size_type num, const void* = 0)
+ allocate(size_type n, const void* = 0)
{
- return static_cast<pointer>(gnu_allocator_tracker::allocate(num *
- sizeof(T)));
+ return static_cast<pointer>(allocation_tracker::allocate(n * sizeof(T)));
}
void
construct(pointer p, const T& value)
{
new (p) T(value);
- gnu_allocator_tracker::construct();
+ allocation_tracker::construct();
}
void
destroy(pointer p)
{
p->~T();
- gnu_allocator_tracker::destroy();
+ allocation_tracker::destroy();
}
void
deallocate(pointer p, size_type num)
- { gnu_allocator_tracker::deallocate(p, num * sizeof(T)); }
+ { allocation_tracker::deallocate(p, num * sizeof(T)); }
};
-template<class T1, class T2>
- bool
- operator==(const gnu_new_allocator<T1>&,
- const gnu_new_allocator<T2>&) throw()
- { return true; }
-
-template<class T1, class T2>
- bool
- operator!=(const gnu_new_allocator<T1>&,
- const gnu_new_allocator<T2>&) throw()
- { return false; }
+ template<class T1, class T2>
+ bool
+ operator==(const tracker_alloc<T1>&, const tracker_alloc<T2>&) throw()
+ { return true; }
+
+ template<class T1, class T2>
+ bool
+ operator!=(const tracker_alloc<T1>&, const tracker_alloc<T2>&) throw()
+ { return false; }
+}; // namespace __gnu_cxx_test
#endif // _GLIBCPP_TESTSUITE_ALLOCATOR_H
-// Utility subroutines for the C++ library testsuite.
+// -*- C++ -*-
+// Utility subroutines for the C++ library testsuite.
//
-// Copyright (C) 2002 Free Software Foundation, Inc.
+// Copyright (C) 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
#include <unistd.h>
#include <sys/time.h>
#include <sys/resource.h>
+#endif
+#include <list>
+#include <string>
+#include <stdexcept>
+#include <clocale>
+#include <locale>
-void
-__set_testsuite_memlimit(float __size)
+namespace __gnu_cxx_test
{
+#ifdef _GLIBCPP_MEM_LIMITS
+ void
+ set_memory_limits(float size)
+ {
struct rlimit r;
// Cater to the absence of rlim_t.
- __typeof__ (r.rlim_cur) limit
- = (__typeof__ (r.rlim_cur))(__size * 1048576);
+ __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur))(size * 1048576);
// Heap size, seems to be common.
#if _GLIBCPP_HAVE_MEMLIMIT_DATA
r.rlim_cur = limit;
setrlimit(RLIMIT_AS, &r);
#endif
-}
+ }
+
#else
-void
-__set_testsuite_memlimit(float) { }
-#endif /* _GLIBCPP_MEM_LIMITS */
+ void
+ set_memory_limits(float) { }
+#endif
+
+ // Useful exceptions.
+ class locale_data : public std::runtime_error
+ {
+ public:
+ explicit
+ locale_data(const std::string& __arg) : runtime_error(__arg) { }
+ };
+ class environment_variable: public std::runtime_error
+ {
+ public:
+ explicit
+ environment_variable(const std::string& __arg) : runtime_error(__arg) { }
+ };
-gnu_counting_struct::size_type gnu_counting_struct::count = 0;
+ class not_found : public std::runtime_error
+ {
+ public:
+ explicit
+ not_found(const std::string& __arg) : runtime_error(__arg) { }
+ };
-unsigned int gnu_copy_constructor::count_ = 0;
-unsigned int gnu_copy_constructor::throw_on_ = 0;
-unsigned int gnu_assignment_operator::count_ = 0;
-unsigned int gnu_assignment_operator::throw_on_ = 0;
-unsigned int gnu_destructor::count_ = 0;
-int gnu_copy_tracker::next_id_ = 0;
+ void
+ run_tests_wrapped_locale(const char* name, const func_callback& l)
+ {
+ using namespace std;
+ bool test = true;
+
+ // Set the global locale.
+ locale loc_name(name);
+ locale orig = locale::global(loc_name);
+
+ const char* res = setlocale(LC_ALL, name);
+ if (res != NULL)
+ {
+ string preLC_ALL = res;
+ for (func_callback::const_iterator i = l.begin(); i != l.end(); ++i)
+ (*i)();
+ string postLC_ALL= setlocale(LC_ALL, NULL);
+ VERIFY( preLC_ALL == postLC_ALL );
+ }
+ else
+ throw environment_variable(string("LC_ALL for") + string(name));
+ }
+
+ void
+ run_tests_wrapped_env(const char* name, const char* env,
+ const func_callback& l)
+ {
+ using namespace std;
+ bool test = true;
+
+#ifdef _GLIBCPP_HAVE_SETENV
+ // Set the global locale.
+ locale loc_name(name);
+ locale orig = locale::global(loc_name);
+
+ // Set environment variable env to value in name.
+ const char* oldENV = getenv(env);
+ if (!setenv(env, name, 1))
+ {
+ for (func_callback::const_iterator i = l.begin(); i != l.end(); ++i)
+ (*i)();
+ setenv(env, oldENV ? oldENV : "", 1);
+ }
+ else
+ throw environment_variable(string(env) + string(" to ") + string(name));
+#else
+ throw not_found("setenv");
+#endif
+ }
+ counter::size_type counter::count = 0;
+ unsigned int copy_constructor::count_ = 0;
+ unsigned int copy_constructor::throw_on_ = 0;
+ unsigned int assignment_operator::count_ = 0;
+ unsigned int assignment_operator::throw_on_ = 0;
+ unsigned int destructor::_M_count = 0;
+ int copy_tracker::next_id_ = 0;
+}; // namespace __cxx_test
-// 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
// #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
#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_;
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);
projects / thirdparty / gcc.git / commitdiff
