OSDN Git Service

9b8c0dd87c43d98cfcf516bde2daa7cc3257bf21
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / testsuite / util / regression / rand / priority_queue / 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             default:
92               switch(get_next_op())
93                 {
94                 case insert_op:
95                   PB_DS_RUN_MTHD(push)
96                     break;
97                 case modify_op:
98                   PB_DS_RUN_MTHD(modify)
99                     break;
100                 case erase_op:
101                   switch(get_next_sub_op(3))
102                     {
103                     case 0:
104                       PB_DS_RUN_MTHD(pop)
105                         break;
106                     case 1:
107                       PB_DS_RUN_MTHD(erase_if)
108                         break;
109                     case 2:
110                       PB_DS_RUN_MTHD(erase_it)
111                         break;
112                     default:
113                       PB_DS_THROW_IF_FAILED(                            false,       "",       m_p_c,      & m_native_c);
114                     }
115                   break;
116                 case clear_op:
117                   PB_DS_RUN_MTHD(clear)
118                     break;
119                 case other_op:
120                   switch(get_next_sub_op(5))
121                     {
122                     case 0:
123                       swap();
124                       break;
125                     case 1:
126                       PB_DS_RUN_MTHD(copy_constructor)
127                         break;
128                     case 2:
129                       PB_DS_RUN_MTHD(it_constructor)
130                         break;
131                     case 3:
132                       PB_DS_RUN_MTHD(assignment_operator)
133                         break;
134                     case 4:
135                       PB_DS_RUN_MTHD(split_join)
136                         break;
137                     default:
138                       PB_DS_THROW_IF_FAILED(                            false,       "",       m_p_c,      & m_native_c);
139                     }
140                   break;
141                 default:
142                   PB_DS_THROW_IF_FAILED(                        false,   "",   m_p_c,  & m_native_c);
143                 };
144             }
145
146           pb.inc();
147         }
148     }
149   catch(...)
150     {
151       std::cerr << "Failed at index " << static_cast<unsigned long>(m_i) <<
152         std::endl;
153
154       delete m_p_c;
155
156       throw;
157     }
158
159   delete m_p_c;
160
161   if (!m_alloc.dbg_ex_allocator<char>::empty())
162     {
163       std::cerr << "detected leaks!" << std::endl;
164
165       std::cerr << m_alloc << std::endl;
166
167       PB_DS_THROW_IF_FAILED(            false, "", m_p_c, & m_native_c);
168     }
169
170   if (m_disp)
171     {
172       std::cout << std::endl;
173
174       delete p_fmt;
175     }
176 }
177
178 PB_DS_CLASS_T_DEC
179 typename PB_DS_CLASS_C_DEC::op
180 PB_DS_CLASS_C_DEC::
181 get_next_op()
182 {
183   const double prob = m_g.get_prob();
184
185   if (prob < m_ip)
186     return (insert_op);
187
188   if (prob < m_ip + m_dp)
189     return (modify_op);
190
191   if (prob < m_ip + m_dp + m_ep)
192     return (erase_op);
193
194   if (prob < m_ip + m_dp + m_ep + m_cp)
195     return (clear_op);
196
197   PB_DS_THROW_IF_FAILED(        prob <= 1, prob, m_p_c,    & m_native_c);
198
199   return (other_op);
200 }
201
202 PB_DS_CLASS_T_DEC
203 size_t
204 PB_DS_CLASS_C_DEC::
205 get_next_sub_op(size_t max)
206 {
207   const double p = m_g.get_prob();
208
209   const double delta = 1 / static_cast<double>(max);
210
211   size_t i = 0;
212
213   while (true)
214     if (p <= (i + 1)*  delta)
215       {
216         PB_DS_THROW_IF_FAILED(
217                               i < max,
218                               static_cast<unsigned long>(i) << " " <<
219                               static_cast<unsigned long>(max),
220                               m_p_c,
221                               & m_native_c);
222
223         return (i);
224       }
225     else
226       ++i;
227 }