OSDN Git Service

2006-09-18 Benjamin Kosnik <bkoz@redhat.com>
[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(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           allocator::set_label(m_i);
69           switch(m_i)
70             {
71             case 0:
72               PB_DS_RUN_MTHD(default_constructor);
73               break;
74             case 1:
75               defs();
76               break;
77             case 2:
78               policy_access();
79               break;
80             case 3:
81               it_copy();
82               break;
83             case 4:
84               it_assign();
85               break;
86             default:
87               switch(get_next_op())
88                 {
89                 case insert_op:
90                   PB_DS_RUN_MTHD(push)
91                     break;
92                 case modify_op:
93                   PB_DS_RUN_MTHD(modify)
94                     break;
95                 case erase_op:
96                   switch(get_next_sub_op(3))
97                     {
98                     case 0:
99                       PB_DS_RUN_MTHD(pop)
100                         break;
101                     case 1:
102                       PB_DS_RUN_MTHD(erase_if)
103                         break;
104                     case 2:
105                       PB_DS_RUN_MTHD(erase_it)
106                         break;
107                     default:
108                       PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
109                     }
110                   break;
111                 case clear_op:
112                   PB_DS_RUN_MTHD(clear)
113                     break;
114                 case other_op:
115                   switch(get_next_sub_op(5))
116                     {
117                     case 0:
118                       swap();
119                       break;
120                     case 1:
121                       PB_DS_RUN_MTHD(copy_constructor)
122                         break;
123                     case 2:
124                       PB_DS_RUN_MTHD(it_constructor)
125                         break;
126                     case 3:
127                       PB_DS_RUN_MTHD(assignment_operator)
128                         break;
129                     case 4:
130                       PB_DS_RUN_MTHD(split_join)
131                         break;
132                     default:
133                       PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
134                     }
135                   break;
136                 default:
137                   PB_DS_THROW_IF_FAILED(false, "", m_p_c,  &m_native_c);
138                 };
139             }
140           pb.inc();
141         }
142     }
143   catch(...)
144     {
145       std::cerr << "Failed at index " << static_cast<unsigned long>(m_i) 
146                 << std::endl;
147       delete m_p_c;
148       throw;
149     }
150   delete m_p_c;
151
152   if (!m_alloc.throw_allocator<char>::empty())
153     {
154       std::cerr << "detected leaks!" << std::endl;
155       std::cerr << m_alloc << std::endl;
156       PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
157     }
158
159   if (m_disp)
160     {
161       std::cout << std::endl;
162       delete p_fmt;
163     }
164 }
165
166 PB_DS_CLASS_T_DEC
167 typename PB_DS_CLASS_C_DEC::op
168 PB_DS_CLASS_C_DEC::
169 get_next_op()
170 {
171   const double prob = m_g.get_prob();
172
173   if (prob < m_ip)
174     return (insert_op);
175
176   if (prob < m_ip + m_dp)
177     return (modify_op);
178
179   if (prob < m_ip + m_dp + m_ep)
180     return (erase_op);
181
182   if (prob < m_ip + m_dp + m_ep + m_cp)
183     return (clear_op);
184
185   PB_DS_THROW_IF_FAILED(prob <= 1, prob, m_p_c, &m_native_c);
186   return other_op;
187 }
188
189 PB_DS_CLASS_T_DEC
190 size_t
191 PB_DS_CLASS_C_DEC::
192 get_next_sub_op(size_t max)
193 {
194   const double p = m_g.get_prob();
195   const double delta = 1 / static_cast<double>(max);
196   size_t i = 0;
197   while (true)
198     if (p <= (i + 1)*  delta)
199       {
200         PB_DS_THROW_IF_FAILED(i < max,
201                               static_cast<unsigned long>(i) << " " <<
202                               static_cast<unsigned long>(max),
203                               m_p_c,
204                               & m_native_c);
205         return i;
206       }
207     else
208       ++i;
209 }