OSDN Git Service

34df60ec294defcac15587afdd3ffd2bac874561
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / testsuite / util / regression / rand / assoc / detail / operator_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 operator_fn_imps.hpp
44  * Containsert a random regression test for a specific container type.
45  */
46
47 PB_DS_CLASS_T_DEC
48 void
49 PB_DS_CLASS_C_DEC::
50 operator()()
51 {
52   xml_result_set_regression_formatter* p_fmt = NULL;
53
54   if (m_disp)
55     p_fmt = new xml_result_set_regression_formatter(
56                                                     string_form<Cntnr>::name(),
57                                                     string_form<Cntnr>::desc());
58
59   m_g.init(m_seed);
60   m_alloc.init(m_seed);
61
62   prog_bar pb(m_n, std::cout, m_disp);
63
64   m_i = 0;
65
66   try
67     {
68       for (m_i = 0; m_i < m_n; ++m_i)
69         {
70           PB_DS_TRACE("Op #" << static_cast<unsigned long>(m_i));
71
72           allocator::set_label(m_i);
73
74           switch(m_i)
75             {
76             case 0:
77               PB_DS_RUN_MTHD(default_constructor);
78               break;
79             case 1:
80               defs();
81               break;
82             case 2:
83               policy_access();
84               break;
85             case 3:
86               it_copy();
87               break;
88             case 4:
89               it_assign();
90               break;
91             case 5:
92               rev_it_copy();
93               break;
94             case 6:
95               rev_it_assign();
96               break;
97             default:
98               switch(get_next_op())
99                 {
100                 case insert_op:
101                   switch(get_next_sub_op(2))
102                     {
103                     case 0:
104                       PB_DS_RUN_MTHD(insert)
105                         break;
106                     case 1:
107                       PB_DS_RUN_MTHD(subscript)
108                         break;
109                     default:
110                       PB_DS_THROW_IF_FAILED(                            false,       "",       m_p_c,      & m_native_c);
111                     }
112                   break;
113                 case erase_op:
114                   switch(get_next_sub_op(4))
115                     {
116                     case 0:
117                       PB_DS_RUN_MTHD(erase)
118                         break;
119                     case 1:
120                       PB_DS_RUN_MTHD(erase_if)
121                         break;
122                     case 2:
123                       PB_DS_RUN_MTHD(erase_it)
124                         break;
125                     case 3:
126                       PB_DS_RUN_MTHD(erase_rev_it)
127                         break;
128                     default:
129                       PB_DS_THROW_IF_FAILED(                            false,       "",       m_p_c,      & m_native_c);
130                     }
131                   break;
132                 case clear_op:
133                   PB_DS_RUN_MTHD(clear)
134                     break;
135                 case other_op:
136                   switch(get_next_sub_op(8))
137                     {
138                     case 0:
139                       swap();
140                       break;
141                     case 1:
142                       PB_DS_RUN_MTHD(copy_constructor)
143                         break;
144                     case 2:
145                       PB_DS_RUN_MTHD(it_constructor)
146                         break;
147                     case 3:
148                       PB_DS_RUN_MTHD(assignment_operator)
149                         break;
150                     case 4:
151                       PB_DS_RUN_MTHD(split_join)
152                         break;
153                     case 5:
154                       resize();
155                       break;
156                     case 6:
157                       get_set_load();
158                       break;
159                     case 7:
160                       get_set_loads();
161                       break;
162                     default:
163                       PB_DS_THROW_IF_FAILED(                            false,       "",       m_p_c,      & m_native_c);
164                     }
165                   break;
166                 default:
167                   PB_DS_THROW_IF_FAILED(                        false,   "",   m_p_c,  & m_native_c);
168                 };
169             }
170
171           pb.inc();
172         }
173     }
174   catch(...)
175     {
176       std::cerr << "Failed at index " << static_cast<unsigned long>(m_i) <<
177         std::endl;
178
179       delete m_p_c;
180
181       throw;
182     }
183
184   delete m_p_c;
185
186   if (!m_alloc.dbg_ex_allocator<char>::empty())
187     {
188       std::cerr << "detected leaks!" << std::endl;
189
190       std::cerr << m_alloc << std::endl;
191
192       PB_DS_THROW_IF_FAILED(            false, "", m_p_c, & m_native_c);
193     }
194
195   if (m_disp)
196     {
197       std::cout << std::endl;
198
199       delete p_fmt;
200     }
201 }
202
203 PB_DS_CLASS_T_DEC
204 typename PB_DS_CLASS_C_DEC::op
205 PB_DS_CLASS_C_DEC::
206 get_next_op()
207 {
208   const double prob = m_g.get_prob();
209
210   if (prob < m_ip)
211     return (insert_op);
212
213   if (prob < m_ip + m_ep)
214     return (erase_op);
215
216   if (prob < m_ip + m_ep + m_cp)
217     return (clear_op);
218
219   PB_DS_THROW_IF_FAILED(        prob <= 1, prob, m_p_c,    & m_native_c);
220
221   return (other_op);
222 }
223
224 PB_DS_CLASS_T_DEC
225 size_t
226 PB_DS_CLASS_C_DEC::
227 get_next_sub_op(size_t max)
228 {
229   const double p = m_g.get_prob();
230
231   const double delta = 1 / static_cast<double>(max);
232
233   size_t i = 0;
234
235   while (true)
236     if (p <= (i + 1)*  delta)
237       {
238         PB_DS_THROW_IF_FAILED(
239                               i < max,
240                               static_cast<unsigned long>(i) << " " <<
241                               static_cast<unsigned long>(max),
242                               m_p_c,
243                               & m_native_c);
244
245         return (i);
246       }
247     else
248       ++i;
249 }