OSDN Git Service

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