OSDN Git Service

82cc024e3a58007c12016288b4db045b2a2dba58
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / testsuite / util / regression / rand / assoc / detail / constructor_destructor_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 constructor_destructor_fn_imps.hpp
44  * Containsert a random regression test for a specific container type.
45  */
46
47 PB_DS_CLASS_T_DEC
48 PB_DS_CLASS_C_DEC::
49 container_rand_regression_test(unsigned long seed, size_t n, size_t m, double tp, double ip, double ep, double cp, double mp, bool disp) :
50   m_seed((seed == 0)?
51          twister_rand_gen::get_time_determined_seed():
52          seed),
53   m_n(n),
54   m_m(m),
55   m_tp(tp),
56   m_ip(ip),
57   m_ep(ep),
58   m_cp(cp),
59   m_mp(mp),
60   m_disp(disp),
61   m_p_c(NULL)
62 { }
63
64 PB_DS_CLASS_T_DEC
65 PB_DS_CLASS_C_DEC::
66 ~container_rand_regression_test()
67 { }
68
69 PB_DS_CLASS_T_DEC
70 bool
71 PB_DS_CLASS_C_DEC::
72 default_constructor()
73 {
74   PB_DS_TRACE("default_constructor");
75
76   bool done = true;
77
78   m_alloc.set_throw_prob(m_tp);
79
80   try
81     {
82       m_p_c = new Cntnr;
83     }
84   catch(forced_exception& )
85     {
86       done = false;
87     }
88
89   if (m_p_c != NULL)
90     PB_DS_COND_COMPARE(*m_p_c, m_native_c);
91
92   return (done);
93 }
94
95 PB_DS_CLASS_T_DEC
96 void
97 PB_DS_CLASS_C_DEC::
98 swap()
99 {
100   PB_DS_TRACE("swap");
101
102   m_alloc.set_throw_prob(0);
103
104   Cntnr* p_c = new Cntnr;
105
106   m_alloc.set_throw_prob(1);
107
108   p_c->swap(*m_p_c);
109
110   std::swap(p_c, m_p_c);
111
112   delete p_c;
113
114   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
115 }
116
117 PB_DS_CLASS_T_DEC
118 bool
119 PB_DS_CLASS_C_DEC::
120 copy_constructor()
121 {
122   PB_DS_TRACE("copy_constructor");
123
124   bool done = true;
125
126   Cntnr* p_c = NULL;
127
128   m_alloc.set_throw_prob(m_tp);
129
130   typename alloc_t::group_throw_prob_adjustor
131     adjust(m_p_c->size());
132
133   try
134     {
135       p_c = new Cntnr(*m_p_c);
136
137       std::swap(p_c, m_p_c);
138     }
139   catch(forced_exception& )
140     {
141       done = false;
142     }
143
144   delete p_c;
145
146   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
147
148   return (done);
149 }
150
151 PB_DS_CLASS_T_DEC
152 bool
153 PB_DS_CLASS_C_DEC::
154 assignment_operator()
155 {
156   PB_DS_TRACE("assignment operator");
157
158   bool done = true;
159
160   Cntnr* p_c = NULL;
161
162   m_alloc.set_throw_prob(m_tp);
163
164   typename alloc_t::group_throw_prob_adjustor
165     adjust(m_p_c->size());
166
167   try
168     {
169       p_c = new Cntnr();
170
171       * p_c =* m_p_c;
172
173       std::swap(p_c, m_p_c);
174     }
175   catch(forced_exception& )
176     {
177       done = false;
178     }
179
180   delete p_c;
181
182   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
183
184   return (done);
185 }
186
187 PB_DS_CLASS_T_DEC
188 bool
189 PB_DS_CLASS_C_DEC::
190 it_constructor()
191 {
192   PB_DS_TRACE("it_constructor");
193
194   return (it_constructor_imp(typename Cntnr::container_category()));
195 }
196
197 PB_DS_CLASS_T_DEC
198 bool
199 PB_DS_CLASS_C_DEC::
200 it_constructor_imp(pb_ds::cc_hash_tag)
201 {
202   bool done = true;
203
204   Cntnr* p_c = NULL;
205
206   m_alloc.set_throw_prob(m_tp);
207
208   typename alloc_t::group_throw_prob_adjustor
209     adjust(m_p_c->size());
210
211   try
212     {
213       switch(get_next_sub_op(8))
214         {
215         case 0:
216           p_c = new Cntnr(m_p_c->get_hash_fn());
217           m_native_c.clear();
218           break;
219         case 1:
220           p_c = new Cntnr(m_p_c->get_hash_fn(),
221                           m_p_c->get_eq_fn());
222           m_native_c.clear();
223           break;
224         case 2:
225           p_c = new Cntnr(m_p_c->get_hash_fn(),
226                           m_p_c->get_eq_fn(),
227                           m_p_c->get_comb_hash_fn());
228           m_native_c.clear();
229           break;
230         case 3:
231           p_c = new Cntnr(m_p_c->get_hash_fn(),
232                           m_p_c->get_eq_fn(),
233                           m_p_c->get_comb_hash_fn(),
234                           m_p_c->get_resize_policy());
235           m_native_c.clear();
236           break;
237         case 4:
238           p_c = new Cntnr(m_p_c->begin(),
239                           m_p_c->end());
240           break;
241         case 5:
242           p_c = new Cntnr(m_p_c->begin(),
243                           m_p_c->end(),
244                           m_p_c->get_hash_fn());
245           break;
246         case 6:
247           p_c = new Cntnr(m_p_c->begin(),
248                           m_p_c->end(),
249                           m_p_c->get_hash_fn(),
250                           m_p_c->get_eq_fn());
251           break;
252         case 7:
253           p_c = new Cntnr(m_p_c->begin(),
254                           m_p_c->end(),
255                           m_p_c->get_hash_fn(),
256                           m_p_c->get_eq_fn(),
257                           m_p_c->get_comb_hash_fn());
258           break;
259         case 8:
260           p_c = new Cntnr(m_p_c->begin(),
261                           m_p_c->end(),
262                           m_p_c->get_hash_fn(),
263                           m_p_c->get_eq_fn(),
264                           m_p_c->get_comb_hash_fn(),
265                           m_p_c->get_resize_policy());
266           break;
267         default:
268           PB_DS_THROW_IF_FAILED(                    false,  "",  m_p_c, & m_native_c);
269         };
270
271       std::swap(p_c, m_p_c);
272     }
273   catch(forced_exception& )
274     {
275       done = false;
276     }
277
278   delete p_c;
279
280   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
281
282   return (done);
283 }
284
285 PB_DS_CLASS_T_DEC
286 bool
287 PB_DS_CLASS_C_DEC::
288 it_constructor_imp(pb_ds::gp_hash_tag)
289 {
290   bool done = true;
291
292   Cntnr* p_c = NULL;
293
294   m_alloc.set_throw_prob(m_tp);
295
296   typename alloc_t::group_throw_prob_adjustor
297     adjust(m_p_c->size());
298
299   try
300     {
301       switch(get_next_sub_op(11))
302         {
303         case 0:
304           p_c = new Cntnr(m_p_c->get_hash_fn());
305           m_native_c.clear();
306           break;
307         case 1:
308           p_c = new Cntnr(m_p_c->get_hash_fn(),
309                           m_p_c->get_eq_fn());
310           m_native_c.clear();
311           break;
312         case 2:
313           p_c = new Cntnr(m_p_c->get_hash_fn(),
314                           m_p_c->get_eq_fn(),
315                           m_p_c->get_comb_probe_fn());
316           m_native_c.clear();
317           break;
318         case 3:
319           p_c = new Cntnr(m_p_c->get_hash_fn(),
320                           m_p_c->get_eq_fn(),
321                           m_p_c->get_comb_probe_fn());
322           m_native_c.clear();
323           break;
324         case 4:
325           p_c = new Cntnr(m_p_c->get_hash_fn(),
326                           m_p_c->get_eq_fn(),
327                           m_p_c->get_comb_probe_fn(),
328                           m_p_c->get_probe_fn());
329           m_native_c.clear();
330           break;
331         case 5:
332           p_c = new Cntnr(m_p_c->get_hash_fn(),
333                           m_p_c->get_eq_fn(),
334                           m_p_c->get_comb_probe_fn(),
335                           m_p_c->get_probe_fn(),
336                           m_p_c->get_resize_policy());
337           m_native_c.clear();
338           break;
339         case 6:
340           p_c = new Cntnr(m_p_c->begin(),
341                           m_p_c->end(),
342                           m_p_c->get_hash_fn());
343           break;
344         case 7:
345           p_c = new Cntnr(m_p_c->begin(),
346                           m_p_c->end(),
347                           m_p_c->get_hash_fn(),
348                           m_p_c->get_eq_fn());
349           break;
350         case 8:
351           p_c = new Cntnr(m_p_c->begin(),
352                           m_p_c->end(),
353                           m_p_c->get_hash_fn(),
354                           m_p_c->get_eq_fn(),
355                           m_p_c->get_comb_probe_fn());
356           break;
357         case 9:
358           p_c = new Cntnr(m_p_c->begin(),
359                           m_p_c->end(),
360                           m_p_c->get_hash_fn(),
361                           m_p_c->get_eq_fn(),
362                           m_p_c->get_comb_probe_fn());
363           break;
364         case 10:
365           p_c = new Cntnr(m_p_c->begin(),
366                           m_p_c->end(),
367                           m_p_c->get_hash_fn(),
368                           m_p_c->get_eq_fn(),
369                           m_p_c->get_comb_probe_fn(),
370                           m_p_c->get_probe_fn());
371           break;
372         case 11:
373           p_c = new Cntnr(m_p_c->begin(),
374                           m_p_c->end(),
375                           m_p_c->get_hash_fn(),
376                           m_p_c->get_eq_fn(),
377                           m_p_c->get_comb_probe_fn(),
378                           m_p_c->get_probe_fn(),
379                           m_p_c->get_resize_policy());
380           break;
381         default:
382           PB_DS_THROW_IF_FAILED(                    false,  "",  m_p_c, & m_native_c);
383         };
384
385       std::swap(p_c, m_p_c);
386     }
387   catch(forced_exception& )
388     {
389       done = false;
390     }
391
392   delete p_c;
393
394   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
395
396   return (done);
397 }
398
399 PB_DS_CLASS_T_DEC
400 bool
401 PB_DS_CLASS_C_DEC::
402 it_constructor_imp(pb_ds::tree_tag)
403 {
404   bool done = true;
405
406   Cntnr* p_c = NULL;
407
408   m_alloc.set_throw_prob(m_tp);
409
410   typename alloc_t::group_throw_prob_adjustor
411     adjust(m_p_c->size());
412
413   try
414     {
415       switch(get_next_sub_op(2))
416         {
417         case 0:
418           p_c = new Cntnr(m_p_c->get_cmp_fn());
419           m_native_c.clear();
420           break;
421         case 1:
422           p_c = new Cntnr(m_p_c->begin(),
423                           m_p_c->end(),
424                           m_p_c->get_cmp_fn());
425           break;
426         default:
427           PB_DS_THROW_IF_FAILED(                false,  "",  m_p_c, & m_native_c);
428         };
429
430       std::swap(p_c, m_p_c);
431     }
432   catch(forced_exception& )
433     {
434       done = false;
435     }
436
437   delete p_c;
438
439   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
440
441   return (done);
442 }
443
444 PB_DS_CLASS_T_DEC
445 bool
446 PB_DS_CLASS_C_DEC::
447 it_constructor_imp(pb_ds::list_update_tag)
448 {
449   bool done = true;
450
451   Cntnr* p_c = NULL;
452
453   m_alloc.set_throw_prob(m_tp);
454
455   typename alloc_t::group_throw_prob_adjustor
456     adjust(m_p_c->size());
457
458   try
459     {
460       p_c = new Cntnr(m_p_c->begin(),
461                       m_p_c->end());
462
463       std::swap(p_c, m_p_c);
464     }
465   catch(forced_exception& )
466     {
467       done = false;
468     }
469
470   delete p_c;
471
472   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
473
474   return (done);
475 }
476
477 PB_DS_CLASS_T_DEC
478 bool
479 PB_DS_CLASS_C_DEC::
480 it_constructor_imp(pb_ds::pat_trie_tag)
481 {
482   bool done = true;
483
484   Cntnr* p_c = NULL;
485
486   m_alloc.set_throw_prob(m_tp);
487
488   typename alloc_t::group_throw_prob_adjustor
489     adjust(m_p_c->size());
490
491   try
492     {
493       switch(get_next_sub_op(2))
494         {
495         case 0:
496           p_c = new Cntnr(m_p_c->get_e_access_traits());
497           m_native_c.clear();
498           break;
499         case 1:
500           p_c = new Cntnr(m_p_c->begin(),
501                           m_p_c->end(),
502                           m_p_c->get_e_access_traits());
503           break;
504         default:
505           PB_DS_THROW_IF_FAILED(                    false,  "",  m_p_c, & m_native_c);
506         };
507
508       std::swap(p_c, m_p_c);
509     }
510   catch(forced_exception& )
511     {
512       done = false;
513     }
514
515   delete p_c;
516
517   PB_DS_COND_COMPARE(*m_p_c, m_native_c);
518
519   return (done);
520 }
521