blob: 8cfaab4412a5fc2af5edca82bfb1af4b99d1263c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
// -*- C++ -*-
//
// Copyright (C) 2012-2017 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
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
#ifndef _TESTSUITE_COUNTER_TYPE_H
#define _TESTSUITE_COUNTER_TYPE_H 1
namespace __gnu_test
{
// Type counting how many constructors or assign operators are invoked.
struct counter_type
{
// Constructor counters:
static int default_count;
static int specialize_count;
static int copy_count;
static int copy_assign_count;
static int less_compare_count;
#if __cplusplus >= 201103L
static int move_count;
static int move_assign_count;
#endif
static int destructor_count;
int val;
counter_type() : val(0)
{ ++default_count; }
counter_type(int inval) : val(inval)
{ ++specialize_count; }
counter_type(const counter_type& in) : val(in.val)
{ ++copy_count; }
~counter_type()
{ ++destructor_count; }
counter_type&
operator=(const counter_type& in)
{
val = in.val;
++copy_assign_count;
return *this;
}
#if __cplusplus >= 201103L
counter_type(counter_type&& in) noexcept
{
val = in.val;
++move_count;
}
counter_type&
operator=(counter_type&& rhs) noexcept
{
val = rhs.val;
++move_assign_count;
return *this;
}
#endif
static void
reset()
{
default_count = 0;
specialize_count = 0;
copy_count = 0;
copy_assign_count = 0;
less_compare_count = 0;
#if __cplusplus >= 201103L
move_count = 0;
move_assign_count = 0;
#endif
destructor_count = 0;
}
bool operator==(const counter_type& rhs) const
{ return val == rhs.val; }
bool operator<(const counter_type& rhs) const
{
++less_compare_count;
return val < rhs.val;
}
};
int counter_type::default_count = 0;
int counter_type::specialize_count = 0;
int counter_type::copy_count = 0;
int counter_type::copy_assign_count = 0;
int counter_type::less_compare_count = 0;
#if __cplusplus >= 201103L
int counter_type::move_count = 0;
int counter_type::move_assign_count = 0;
#endif
int counter_type::destructor_count = 0;
struct counter_type_hasher
{
std::size_t operator()(const counter_type& c) const
{
return c.val;
}
};
} // namespace __gnu_test
#endif
|