OSDN Git Service

0b2a62c0ecdb216bb81c73946c28cb3bb0fb1c99
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / testsuite / util / regression / rand / assoc / detail / erase_fn_imps.hpp
1 // -*- C++ -*-
2
3 // Copyright (C) 2005, 2006 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library.  This library is free
6 // software; you can redistribute it and/or modify it under the terms
7 // of the GNU General Public License as published by the Free Software
8 // Foundation; either version 2, or (at your option) any later
9 // version.
10
11 // This library is distributed in the hope that it will be useful, but
12 // WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License
17 // along with this library; see the file COPYING.  If not, write to
18 // the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
19 // MA 02111-1307, USA.
20
21 // As a special exception, you may use this file as part of a free
22 // software library without restriction.  Specifically, if other files
23 // instantiate templates or use macros or inline functions from this
24 // file, or you compile this file and link it with other files to
25 // produce an executable, this file does not by itself cause the
26 // resulting executable to be covered by the GNU General Public
27 // License.  This exception does not however invalidate any other
28 // reasons why the executable file might be covered by the GNU General
29 // Public License.
30
31 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
32
33 // Permission to use, copy, modify, sell, and distribute this software
34 // is hereby granted without fee, provided that the above copyright
35 // notice appears in all copies, and that both that copyright notice
36 // and this permission notice appear in supporting documentation. None
37 // of the above authors, nor IBM Haifa Research Laboratories, make any
38 // representation about the suitability of this software for any
39 // purpose. It is provided "as is" without express or implied
40 // warranty.
41
42 /**
43  * @file erase_fn_imps.hpp
44  * Containsert a random regression test for a specific container type.
45  */
46
47 PB_DS_CLASS_T_DEC
48 bool
49 PB_DS_CLASS_C_DEC::
50 erase()
51 {
52   PB_DS_TRACE("erase");
53
54   bool done = true;
55
56   PB_DS_SET_DESTRUCT_PRINT
57
58     m_alloc.set_throw_prob(0);
59
60   const key_type k =
61     test_traits::generate_key(m_g, m_m);
62
63   m_alloc.set_throw_prob(m_tp);
64
65   try
66     {
67       const bool cntnd = m_p_c->find(k) != m_p_c->end();
68
69       PB_DS_THROW_IF_FAILED(
70                             cntnd ==(m_native_c.find(test_traits::native_key(k)) != m_native_c.end()),
71                             test_traits::key_to_string(k),
72                             m_p_c,
73                             & m_native_c);
74
75       const bool ersd = m_p_c->erase(k);
76
77       const bool native_ersd =
78         m_native_c.erase(test_traits::native_key(k)) != 0;
79
80       PB_DS_THROW_IF_FAILED(
81                             ersd == native_ersd,
82                             ersd << " " << native_ersd,
83                             m_p_c,
84                             & m_native_c);
85
86       PB_DS_THROW_IF_FAILED(
87                             m_p_c->find(k) == m_p_c->end(),
88                             "",
89                             m_p_c,
90                             & m_native_c);
91     }
92   catch(forced_exception& )
93     {
94       done = false;
95
96       PB_DS_THROW_IF_FAILED(            container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
97     }
98
99   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
100
101   PB_DS_CANCEL_DESTRUCT_PRINT
102
103     return (done);
104 }
105
106 PB_DS_CLASS_T_DEC
107 bool
108 PB_DS_CLASS_C_DEC::
109 erase_if()
110 {
111   PB_DS_TRACE("erase_if");
112
113   bool done = true;
114
115   PB_DS_SET_DESTRUCT_PRINT
116
117     try
118       {
119         typedef
120           typename std::iterator_traits<
121           typename cntnr::iterator>::reference
122           it_const_reference;
123
124         typedef
125           typename test_traits::template erase_if_fn<
126           value_type>
127           erase_if_fn_t;
128
129         m_alloc.set_throw_prob(m_tp);
130
131         const size_t ersd =
132           m_p_c->erase_if(erase_if_fn_t());
133
134         const size_t native_ersd =
135           test_traits::erase_if(m_native_c);
136
137         PB_DS_THROW_IF_FAILED(
138                               ersd == native_ersd,
139                               static_cast<unsigned long>(ersd) << " " <<
140                               static_cast<unsigned long>(native_ersd),
141                               m_p_c,
142                               & m_native_c);
143       }
144     catch(forced_exception& )
145       {
146         done = false;
147
148         PB_DS_THROW_IF_FAILED(            container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
149       }
150
151   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
152
153   PB_DS_CANCEL_DESTRUCT_PRINT
154
155     return (done);
156 }
157
158 PB_DS_CLASS_T_DEC
159 bool
160 PB_DS_CLASS_C_DEC::
161 erase_it()
162 {
163   enum
164     {
165       erase_iterators =
166       container_traits::order_preserving
167     };
168
169   return (erase_it_imp(pb_ds::detail::integral_constant<int,erase_iterators>()));
170 }
171
172 PB_DS_CLASS_T_DEC
173 bool
174 PB_DS_CLASS_C_DEC::
175 erase_it_imp(pb_ds::detail::false_type)
176 {
177   return (true);
178 }
179
180 PB_DS_CLASS_T_DEC
181 bool
182 PB_DS_CLASS_C_DEC::
183 erase_it_imp(pb_ds::detail::true_type)
184 {
185   PB_DS_TRACE("erase_it");
186
187   bool done = true;
188
189   PB_DS_SET_DESTRUCT_PRINT
190
191     try
192       {
193         m_alloc.set_throw_prob(0);
194
195         const key_type k =
196           test_traits::generate_key(m_g, m_m);
197
198         m_alloc.set_throw_prob(m_tp);
199
200         typename cntnr::iterator found_it = m_p_c->find(k);
201
202         typename native_type::iterator native_it = m_native_c.find(
203                                                                    test_traits::native_key(k));
204
205         const bool found = found_it != m_p_c->end();
206         const bool native_found = native_it != m_native_c.end();
207
208         PB_DS_THROW_IF_FAILED(
209                               found == native_found,
210                               found << " " <<    native_found,
211                               m_p_c,
212                               & m_native_c);
213
214         typename cntnr::const_iterator next_it = found_it;
215         if (next_it != m_p_c->end())
216           ++next_it;
217
218         typename cntnr::iterator next_ers_it =
219           m_p_c->erase(found_it);
220
221         if (native_it != m_native_c.end())
222           m_native_c.erase(native_it);
223
224         bool range_guarantee =
225           pb_ds::detail::is_same<
226           typename container_traits::invalidation_guarantee,
227           pb_ds::range_invalidation_guarantee>::value ;
228
229         if (range_guarantee)
230           PB_DS_THROW_IF_FAILED(                next_ers_it == next_it,  "",  m_p_c, & m_native_c);
231       }
232     catch(forced_exception& )
233       {
234         done = false;
235
236         PB_DS_THROW_IF_FAILED(            container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
237       }
238
239   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
240
241   PB_DS_CANCEL_DESTRUCT_PRINT
242
243     return (done);
244 }
245
246 PB_DS_CLASS_T_DEC
247 bool
248 PB_DS_CLASS_C_DEC::
249 erase_rev_it()
250 {
251   enum
252     {
253       erase_iterators =
254       container_traits::order_preserving&& 
255       container_traits::reverse_iteration
256     };
257
258   return (erase_rev_it_imp(pb_ds::detail::integral_constant<int,erase_iterators>()));
259 }
260
261 PB_DS_CLASS_T_DEC
262 bool
263 PB_DS_CLASS_C_DEC::
264 erase_rev_it_imp(pb_ds::detail::false_type)
265 {
266   return (true);
267 }
268
269 PB_DS_CLASS_T_DEC
270 bool
271 PB_DS_CLASS_C_DEC::
272 erase_rev_it_imp(pb_ds::detail::true_type)
273 {
274   PB_DS_TRACE("erase_rev_it");
275
276   bool done = true;
277
278   PB_DS_SET_DESTRUCT_PRINT
279
280     try
281       {
282         m_alloc.set_throw_prob(0);
283
284         const key_type k =
285           test_traits::generate_key(m_g, m_m);
286
287         m_alloc.set_throw_prob(m_tp);
288
289         typename cntnr::iterator found_it = m_p_c->find(k);
290
291         typename native_type::iterator native_it = m_native_c.find(
292                                                                    test_traits::native_key(k));
293
294         typename cntnr::const_reverse_iterator next_it = found_it;
295         if (next_it != m_p_c->end())
296           ++next_it;
297
298         typename cntnr::reverse_iterator next_ers_it =
299           m_p_c->erase((typename cntnr::reverse_iterator)found_it);
300
301         PB_DS_THROW_IF_FAILED(            next_ers_it == next_it, "", m_p_c, & m_native_c);
302
303         if (native_it != m_native_c.end())
304           m_native_c.erase(native_it);
305       }
306     catch(forced_exception& )
307       {
308         done = false;
309
310         PB_DS_THROW_IF_FAILED(            container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
311       }
312
313   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
314
315   PB_DS_CANCEL_DESTRUCT_PRINT
316
317     return (done);
318 }
319