URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [testsuite/] [util/] [regression/] [rand/] [priority_queue/] [container_rand_regression_test.tcc] - Blame information for rev 742

Details | Compare with Previous | View Log


// -*- C++ -*-
 
// Copyright (C) 2005, 2006, 2008, 2009, 2010 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 3, or (at your option) any later
// version.
 
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
 
// You should have received a copy of the GNU General Public License
// along with this library; see the file COPYING3.  If not see
// .
 
 
// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
 
// Permission to use, copy, modify, sell, and distribute this software
// is hereby granted without fee, provided that the above copyright
// notice appears in all copies, and that both that copyright notice
// and this permission notice appear in supporting documentation. None
// of the above authors, nor IBM Haifa Research Laboratories, make any
// representation about the suitability of this software for any
// purpose. It is provided "as is" without express or implied
// warranty.
 
/**
 * @file container_rand_regression_test.tcc
 * Contains a random regression test for a specific container type.
 */
 
#ifndef PB_DS_CONTAINER_RAND_REGRESSION_TEST_TCC
#define PB_DS_CONTAINER_RAND_REGRESSION_TEST_TCC
 
  // Constructor, copy constructor, assignment and destructor.
PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
container_rand_regression_test(unsigned long seed, size_t n, size_t m,
                               double tp, double ip, double dp, double ep,
                               double cp, double mp, bool disp)
: m_seed(seed == 0 ? twister_rand_gen::get_time_determined_seed(): seed),
  m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_dp(dp), m_ep(ep), m_cp(cp),
  m_mp(mp), m_disp(disp), m_p_c(0)
{ }
 
PB_DS_CLASS_T_DEC
PB_DS_CLASS_C_DEC::
~container_rand_regression_test()
{ }
 
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
default_constructor()
{
  PB_DS_TRACE("default_constructor");
  bool done = true;
  m_alloc.set_probability(m_tp);
 
  try
    {
      m_p_c = new Cntnr;
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
    }
 
  if (m_p_c)
    PB_DS_COND_COMPARE(*m_p_c, m_native_c);
 
  return done;
}
 
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
swap()
{
  PB_DS_TRACE("swap");
  m_alloc.set_probability(0);
  Cntnr* p_c = new Cntnr;
  m_alloc.set_probability(1);
  p_c->swap(*m_p_c);
  std::swap(p_c, m_p_c);
  delete p_c;
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
}
 
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
copy_constructor()
{
  PB_DS_TRACE("copy_constructor");
  bool done = true;
  Cntnr* p_c = 0;
  m_alloc.set_probability(m_tp);
 
  typedef typename allocator_type::group_adjustor adjustor;
  adjustor adjust(m_p_c->size());
 
  try
    {
      p_c = new Cntnr(*m_p_c);
      std::swap(p_c, m_p_c);
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
    }
 
  delete p_c;
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  return done;
}
 
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
assignment_operator()
{
  PB_DS_TRACE("assignment operator");
  bool done = true;
  Cntnr* p_c = 0;
  m_alloc.set_probability(m_tp);
 
  typedef typename allocator_type::group_adjustor adjustor;
  adjustor adjust(m_p_c->size());
 
  try
    {
      p_c = new Cntnr();
      *p_c = *m_p_c;
      std::swap(p_c, m_p_c);
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
    }
 
  delete p_c;
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  return done;
}
 
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
it_constructor()
{
  bool done = true;
  Cntnr* p_c = 0;
  m_alloc.set_probability(m_tp);
  typedef typename allocator_type::group_adjustor adjustor;
  adjustor adjust(m_p_c->size());
 
  try
    {
      switch(get_next_sub_op(3))
        {
        case 0:
          p_c = new Cntnr(m_p_c->get_cmp_fn());
          m_native_c.clear();
          break;
        case 1:
          p_c = new Cntnr(m_p_c->begin(), m_p_c->end());
          break;
        case 2:
          p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_cmp_fn());
          break;
        default:
          _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
        };
 
      std::swap(p_c, m_p_c);
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
    }
 
  delete p_c;
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  return done;
}
 
 
  // Compare.
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
cmp(const Cntnr& c, const native_type& native, const std::string& callfn)
{
  destructor_printer notify(__FUNCTION__);
 
  try
    {
      m_alloc.set_probability(1);
 
      const size_t size = c.size();
      const size_t native_size = native.size();
      _GLIBCXX_THROW_IF(size != native_size, size << " " << native_size,
                        &c, &native);
 
      const bool empty = c.empty();
      const bool native_empty = native.empty();
      _GLIBCXX_THROW_IF(empty != native_empty, empty << " " << native_empty,
                        &c, &native);
 
      const size_t it_size = std::distance(c.begin(), c.end());
      _GLIBCXX_THROW_IF(it_size != size, it_size << " " << size, &c, &native);
 
      if (!c.empty())
        {
          const std::string native_top = native.top();
          const std::string top = test_traits::native_value(c.top());
          const bool top_smaller = std::less()(top, native_top);
          const bool top_larger = std::less()(native_top, top);
 
          if (top_smaller || top_larger)
            _GLIBCXX_THROW_IF(true, top << " " << native_top, &c, &native);
        }
    }
  catch(...)
    {
      _GLIBCXX_THROW_IF(true, "call-fn: " + callfn, &c, &native);
    }
 
  notify.cancel();
}
 
  // Operators.
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
operator()()
{
  typedef xml_result_set_regression_formatter formatter_type;
  formatter_type* p_fmt = 0;
  if (m_disp)
    p_fmt = new formatter_type(string_form::name(),
                               string_form::desc());
 
  m_g.init(m_seed);
  m_alloc.seed(m_seed);
 
  // The __throw_allocator::_S_label defaults to 0, so to make things
  // easier and more precise when debugging, start at 1.
  const size_t starting_label(1);
 
  try
    {
      prog_bar pb(m_n, std::cout, m_disp);
 
      for (m_i = starting_label; m_i <= m_n; ++m_i)
        {
          PB_DS_TRACE("Op #" << m_i);
 
          // Track allocation from this point only.
          allocator_type::set_label(m_i);
          switch(m_i)
            {
            case 1:
              PB_DS_RUN_MTHD(default_constructor);
              break;
            case 2:
              defs();
              break;
            case 3:
              policy_access();
              break;
            case 4:
              it_copy();
              break;
            case 5:
              it_assign();
              break;
            default:
              switch(get_next_op())
                {
                case insert_op:
                  PB_DS_RUN_MTHD(push)
                    break;
                case modify_op:
                  PB_DS_RUN_MTHD(modify)
                    break;
                case erase_op:
                  switch(get_next_sub_op(3))
                    {
                    case 0:
                      PB_DS_RUN_MTHD(pop)
                        break;
                    case 1:
                      PB_DS_RUN_MTHD(erase_if)
                        break;
                    case 2:
                      PB_DS_RUN_MTHD(erase_it)
                        break;
                    default:
                      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
                    }
                  break;
                case clear_op:
                  PB_DS_RUN_MTHD(clear)
                    break;
                case other_op:
                  switch(get_next_sub_op(5))
                    {
                    case 0:
                      swap();
                      break;
                    case 1:
                      PB_DS_RUN_MTHD(copy_constructor)
                        break;
                    case 2:
                      PB_DS_RUN_MTHD(it_constructor)
                        break;
                    case 3:
                      PB_DS_RUN_MTHD(assignment_operator)
                        break;
                    case 4:
                      PB_DS_RUN_MTHD(split_join)
                        break;
                    default:
                      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
                    }
                  break;
                default:
                  _GLIBCXX_THROW_IF(true, "", m_p_c,  &m_native_c);
                };
            }
          pb.inc();
        }
    }
  catch (...)
    {
      std::cerr << "Failed at index " << m_i << std::endl;
      delete m_p_c;
      throw;
    }
 
  // Clean up, then check for allocation by special label, set above.
  allocator_type::set_label(0);
  delete m_p_c;
 
  try
    {
      for (size_t n = starting_label; n <= m_n; ++n)
        m_alloc.check_allocated(n);
    }
  catch (std::logic_error& obj)
    {
      // On fail, check_allocated should throw std::logic_error.
      std::cerr << obj.what() << std::endl;
      std::cerr << typeid(Cntnr).name() << std::endl;
      throw;
    }
 
  // Reset throw probability.
  m_alloc.set_probability(0);
 
  if (m_disp)
    {
      std::cout << std::endl;
      delete p_fmt;
    }
}
 
PB_DS_CLASS_T_DEC
typename PB_DS_CLASS_C_DEC::op
PB_DS_CLASS_C_DEC::
get_next_op()
{
  const double prob = m_g.get_prob();
 
  if (prob < m_ip)
    return insert_op;
 
  if (prob < m_ip + m_dp)
    return modify_op;
 
  if (prob < m_ip + m_dp + m_ep)
    return erase_op;
 
  if (prob < m_ip + m_dp + m_ep + m_cp)
    return clear_op;
 
  _GLIBCXX_THROW_IF(prob > 1, prob, m_p_c, &m_native_c);
  return other_op;
}
 
PB_DS_CLASS_T_DEC
size_t
PB_DS_CLASS_C_DEC::
get_next_sub_op(size_t max)
{
  const double p = m_g.get_prob();
  const double delta = 1 / static_cast(max);
  size_t i = 0;
  while (true)
    if (p <= (i + 1) * delta)
      {
        _GLIBCXX_THROW_IF(i >= max, i << " " << max, m_p_c, &m_native_c);
        return i;
      }
    else
      ++i;
}
 
  // Insert.
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
push()
{
  PB_DS_TRACE("push");
  bool done = true;
  destructor_printer notify(__FUNCTION__);
 
    try
      {
        m_alloc.set_probability(0);
        value_type v = test_traits::generate_value(m_g, m_m);
        m_alloc.set_probability(m_tp);
        const typename cntnr::size_type sz = m_p_c->size();
        m_p_c->push(v);
        _GLIBCXX_THROW_IF(sz != m_p_c->size() - 1, sz, m_p_c, &m_native_c);
        m_native_c.push(test_traits::native_value(v));
      }
    catch(__gnu_cxx::forced_error&)
      {
        done = false;
      }
    catch(...)
      {
        _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
      }
 
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  notify.cancel();
  return done;
}
 
 
  // Modify.
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
modify()
{
  PB_DS_TRACE("modify");
  destructor_printer notify(__FUNCTION__);
 
  bool done = true;
  try
    {
      m_alloc.set_probability(0);
      value_type v = test_traits::generate_value(m_g, m_m);
 
      m_alloc.set_probability(m_tp);
      typename cntnr::iterator it = m_p_c->begin();
      std::advance(it, m_g.get_unsigned_long(0, m_p_c->size()));
      if (it != m_p_c->end())
        {
          typedef typename test_traits::native_value_type native_value_type;
          native_value_type native_v = test_traits::native_value(*it);
          native_value_type new_native_v = test_traits::native_value(v);
          m_p_c->modify(it, v);
          m_native_c.modify(native_v, new_native_v);
        }
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
    }
 
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  notify.cancel();
  return done;
}
 
  // Clear.
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
clear()
{
  PB_DS_TRACE("clear");
  m_p_c->clear();
  m_native_c.clear();
  return true;
}
 
  // Erase.
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
pop()
{
  PB_DS_TRACE("pop");
  destructor_printer notify(__FUNCTION__);
 
  bool done = true;
  try
    {
      m_alloc.set_probability(1);
      if (!m_p_c->empty())
        {
          m_p_c->pop();
          m_native_c.pop();
        }
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
    }
 
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  notify.cancel();
  return done;
}
 
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
erase_if()
{
  PB_DS_TRACE("erase_if");
  destructor_printer notify(__FUNCTION__);
 
  bool done = true;
  try
    {
      typedef
        typename std::iterator_traits::reference
        it_const_reference;
 
      m_alloc.set_probability(1);
 
      typedef
        typename test_traits::template erase_if_fn
        erase_if_fn_t;
 
      const size_t ersd = m_p_c->erase_if(erase_if_fn_t());
 
      typedef
        typename test_traits::template erase_if_fn
        native_erase_if_fn_t;
 
      const size_t native_ersd = m_native_c.erase_if(native_erase_if_fn_t());
 
      _GLIBCXX_THROW_IF(ersd != native_ersd, ersd << " " << native_ersd,
                        m_p_c, &m_native_c);
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
    }
 
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  notify.cancel();
  return done;
}
 
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
erase_it()
{
  PB_DS_TRACE("erase_it");
  destructor_printer notify(__FUNCTION__);
 
  bool done = true;
  try
    {
      m_alloc.set_probability(1);
      typename cntnr::iterator it = m_p_c->begin();
      std::advance(it, m_g.get_unsigned_long(0, m_p_c->size()));
 
      if (it != m_p_c->end())
        {
          m_native_c.erase(*it);
          m_p_c->erase(it);
        }
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
    }
 
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  notify.cancel();
  return done;
}
 
  // Defs.
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
defs()
{
  // General container types.
  typedef typename Cntnr::size_type test_size_type;
  typedef typename Cntnr::difference_type difference_type;
  value_defs();
  iterator_defs();
  policy_defs();
}
 
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
value_defs()
{
  typedef typename Cntnr::value_type test_value_type;
  typedef typename Cntnr::reference test_reference;
  typedef typename Cntnr::const_reference test_const_reference;
  typedef typename Cntnr::pointer test_pointer;
  typedef typename Cntnr::const_pointer test_const_pointer;
}
 
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
ds_defs()
{
  typedef typename Cntnr::container_category test_container_category;
}
 
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
iterator_defs()
{
  typedef typename Cntnr::point_iterator test_point_iterator;
  typedef typename Cntnr::point_const_iterator const_test_point_iterator;
  typedef typename Cntnr::iterator test_iterator;
  typedef typename Cntnr::const_iterator const_test_iterator;
}
 
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
policy_defs()
{
  typedef typename Cntnr::allocator_type test_allocator;
  typedef typename Cntnr::cmp_fn test_cmp_fn;
}
 
 
// Policy access.
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
policy_access()
{
  PB_DS_TRACE("policy_access");
 
  {
    typename Cntnr::cmp_fn& r_t = m_p_c->get_cmp_fn();
    assert(&r_t);
  }
 
  {
    const typename Cntnr::cmp_fn& r_t =((const Cntnr& )*m_p_c).get_cmp_fn();
    assert(&r_t);
  }
}
 
// Split join.
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
split_join()
{
  PB_DS_TRACE("split_join");
  destructor_printer notify(__FUNCTION__);
 
  bool done = true;
  try
    {
      m_alloc.set_probability(0);
      Cntnr lhs(*m_p_c);
      Cntnr rhs;
      native_type native_lhs(m_native_c);
      m_alloc.set_probability(m_tp);
 
      typedef typename test_traits::template erase_if_fn split_fn_t;
      lhs.split(split_fn_t(), rhs);
 
      typedef typename test_traits::template erase_if_fn
        native_split_fn_t;
 
      native_type native_rhs;
      native_lhs.split(native_split_fn_t(), native_rhs);
      PB_DS_COND_COMPARE(lhs, native_lhs);
      PB_DS_COND_COMPARE(rhs, native_rhs);
 
      m_alloc.set_probability(m_tp);
 
      if (m_g.get_prob() < 0.5)
        lhs.swap(rhs);
      lhs.join(rhs);
 
      _GLIBCXX_THROW_IF(rhs.size() != 0, rhs.size(), m_p_c, &m_native_c);
      _GLIBCXX_THROW_IF(!rhs.empty(), rhs.size(), m_p_c, &m_native_c);
    }
  catch(__gnu_cxx::forced_error&)
    {
      done = false;
      const bool b = __gnu_pbds::container_traits::split_join_can_throw;
      _GLIBCXX_THROW_IF(!b, b, m_p_c, &m_native_c);
    }
 
  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
  notify.cancel();
  return done;
}
 
// Iterator conversions.
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
it_copy()
{
  PB_DS_TRACE("it_copy");
 
  {
    typename cntnr::iterator it = m_p_c->end();
    typename cntnr::const_iterator const_it(it);
    _GLIBCXX_THROW_IF(const_it != it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(const_it == it), "", m_p_c, &m_native_c);
  }
 
  {
    typename cntnr::const_iterator const_it = m_p_c->end();
    typename cntnr::point_const_iterator const_find_it(const_it);
    _GLIBCXX_THROW_IF(const_find_it != const_it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(const_find_it == const_it), "", m_p_c, &m_native_c);
  }
 
  {
    typename cntnr::iterator it = m_p_c->end();
    typename cntnr::point_const_iterator const_find_it1(it);
    _GLIBCXX_THROW_IF(const_find_it1 != it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(const_find_it1 == it), "", m_p_c, &m_native_c);
 
    typename cntnr::point_iterator find_it1(it);
    _GLIBCXX_THROW_IF(find_it1 != it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(find_it1 == it), "", m_p_c, &m_native_c);
 
    typename cntnr::point_iterator find_it = m_p_c->end();
    typename cntnr::point_const_iterator const_find_it(find_it);
    _GLIBCXX_THROW_IF(find_it != const_find_it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(find_it == const_find_it), "", m_p_c, &m_native_c);
  }
}
 
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
it_assign()
{
  PB_DS_TRACE("it_assign");
 
  {
    typename cntnr::iterator it = m_p_c->end();
    typename cntnr::const_iterator const_it;
    const_it = it;
    _GLIBCXX_THROW_IF(const_it != it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(const_it == it), "", m_p_c, &m_native_c);
 
    typename cntnr::point_const_iterator const_find_it;
    const_find_it = it;
    _GLIBCXX_THROW_IF(const_find_it != it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(const_find_it == it), "", m_p_c, &m_native_c);
 
    typename cntnr::point_iterator find_it;
    find_it = it;
    _GLIBCXX_THROW_IF(find_it != it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(find_it == it), "", m_p_c, &m_native_c);
  }
 
  {
    typename cntnr::const_iterator const_it = m_p_c->end();
    typename cntnr::point_const_iterator const_find_it;
    const_find_it = const_it;
    _GLIBCXX_THROW_IF(const_find_it != const_it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(const_find_it == const_it), "", m_p_c, &m_native_c);
  }
 
  {
    typename cntnr::point_iterator find_it = m_p_c->end();
    typename cntnr::point_const_iterator const_find_it;
    const_find_it = find_it;
    _GLIBCXX_THROW_IF(find_it != const_find_it, "", m_p_c, &m_native_c);
    _GLIBCXX_THROW_IF(!(find_it == const_find_it), "", m_p_c, &m_native_c);
  }
}
 
 
// Diagnostics.
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
print_container(const native_type& cnt, std::ostream& os) const
{
  m_alloc.set_probability(0);
  native_type cpy(cnt);
  while (!cpy.empty())
    {
      os << cpy.top() << std::endl;
      cpy.pop();
    }
}
 
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
print_container(const cntnr& cnt, std::ostream& os) const
{
  typedef typename cntnr::const_iterator const_iterator;
  m_alloc.set_probability(0);
  for (const_iterator it = cnt.begin(); it != cnt.end(); ++it)
    os << *it << std::endl;
}
 
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [testsuite/] [util/] [regression/] [rand/] [priority_queue/] [container_rand_regression_test.tcc] - Blame information for rev 742

Line No.	Rev	Author	Line
1	742	jeremybenn	`// -- C++ --`
2
3			`// Copyright (C) 2005, 2006, 2008, 2009, 2010 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 3, 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 COPYING3. If not see`
18			`// .`
19
20
21			`// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.`
22
23			`// Permission to use, copy, modify, sell, and distribute this software`
24			`// is hereby granted without fee, provided that the above copyright`
25			`// notice appears in all copies, and that both that copyright notice`
26			`// and this permission notice appear in supporting documentation. None`
27			`// of the above authors, nor IBM Haifa Research Laboratories, make any`
28			`// representation about the suitability of this software for any`
29			`// purpose. It is provided "as is" without express or implied`
30			`// warranty.`
31
32			`/**`
33			`* @file container_rand_regression_test.tcc`
34			`* Contains a random regression test for a specific container type.`
35			`*/`
36
37			`#ifndef PB_DS_CONTAINER_RAND_REGRESSION_TEST_TCC`
38			`#define PB_DS_CONTAINER_RAND_REGRESSION_TEST_TCC`
39
40			`// Constructor, copy constructor, assignment and destructor.`
41			`PB_DS_CLASS_T_DEC`
42			`PB_DS_CLASS_C_DEC::`
43			`container_rand_regression_test(unsigned long seed, size_t n, size_t m,`
44			`double tp, double ip, double dp, double ep,`
45			`double cp, double mp, bool disp)`
46			`: m_seed(seed == 0 ? twister_rand_gen::get_time_determined_seed(): seed),`
47			`m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_dp(dp), m_ep(ep), m_cp(cp),`
48			`m_mp(mp), m_disp(disp), m_p_c(0)`
49			`{ }`
50
51			`PB_DS_CLASS_T_DEC`
52			`PB_DS_CLASS_C_DEC::`
53			`~container_rand_regression_test()`
54			`{ }`
55
56			`PB_DS_CLASS_T_DEC`
57			`bool`
58			`PB_DS_CLASS_C_DEC::`
59			`default_constructor()`
60			`{`
61			`PB_DS_TRACE("default_constructor");`
62			`bool done = true;`
63			`m_alloc.set_probability(m_tp);`
64
65			`try`
66			`{`
67			`m_p_c = new Cntnr;`
68			`}`
69			`catch(__gnu_cxx::forced_error&)`
70			`{`
71			`done = false;`
72			`}`
73
74			`if (m_p_c)`
75			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
76
77			`return done;`
78			`}`
79
80			`PB_DS_CLASS_T_DEC`
81			`void`
82			`PB_DS_CLASS_C_DEC::`
83			`swap()`
84			`{`
85			`PB_DS_TRACE("swap");`
86			`m_alloc.set_probability(0);`
87			`Cntnr* p_c = new Cntnr;`
88			`m_alloc.set_probability(1);`
89			`p_c->swap(*m_p_c);`
90			`std::swap(p_c, m_p_c);`
91			`delete p_c;`
92			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
93			`}`
94
95			`PB_DS_CLASS_T_DEC`
96			`bool`
97			`PB_DS_CLASS_C_DEC::`
98			`copy_constructor()`
99			`{`
100			`PB_DS_TRACE("copy_constructor");`
101			`bool done = true;`
102			`Cntnr* p_c = 0;`
103			`m_alloc.set_probability(m_tp);`
104
105			`typedef typename allocator_type::group_adjustor adjustor;`
106			`adjustor adjust(m_p_c->size());`
107
108			`try`
109			`{`
110			`p_c = new Cntnr(*m_p_c);`
111			`std::swap(p_c, m_p_c);`
112			`}`
113			`catch(__gnu_cxx::forced_error&)`
114			`{`
115			`done = false;`
116			`}`
117
118			`delete p_c;`
119			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
120			`return done;`
121			`}`
122
123			`PB_DS_CLASS_T_DEC`
124			`bool`
125			`PB_DS_CLASS_C_DEC::`
126			`assignment_operator()`
127			`{`
128			`PB_DS_TRACE("assignment operator");`
129			`bool done = true;`
130			`Cntnr* p_c = 0;`
131			`m_alloc.set_probability(m_tp);`
132
133			`typedef typename allocator_type::group_adjustor adjustor;`
134			`adjustor adjust(m_p_c->size());`
135
136			`try`
137			`{`
138			`p_c = new Cntnr();`
139			`p_c = m_p_c;`
140			`std::swap(p_c, m_p_c);`
141			`}`
142			`catch(__gnu_cxx::forced_error&)`
143			`{`
144			`done = false;`
145			`}`
146
147			`delete p_c;`
148			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
149			`return done;`
150			`}`
151
152			`PB_DS_CLASS_T_DEC`
153			`bool`
154			`PB_DS_CLASS_C_DEC::`
155			`it_constructor()`
156			`{`
157			`bool done = true;`
158			`Cntnr* p_c = 0;`
159			`m_alloc.set_probability(m_tp);`
160			`typedef typename allocator_type::group_adjustor adjustor;`
161			`adjustor adjust(m_p_c->size());`
162
163			`try`
164			`{`
165			`switch(get_next_sub_op(3))`
166			`{`
167			`case 0:`
168			`p_c = new Cntnr(m_p_c->get_cmp_fn());`
169			`m_native_c.clear();`
170			`break;`
171			`case 1:`
172			`p_c = new Cntnr(m_p_c->begin(), m_p_c->end());`
173			`break;`
174			`case 2:`
175			`p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_cmp_fn());`
176			`break;`
177			`default:`
178			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
179			`};`
180
181			`std::swap(p_c, m_p_c);`
182			`}`
183			`catch(__gnu_cxx::forced_error&)`
184			`{`
185			`done = false;`
186			`}`
187
188			`delete p_c;`
189			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
190			`return done;`
191			`}`
192
193
194			`// Compare.`
195			`PB_DS_CLASS_T_DEC`
196			`void`
197			`PB_DS_CLASS_C_DEC::`
198			`cmp(const Cntnr& c, const native_type& native, const std::string& callfn)`
199			`{`
200			`destructor_printer notify(__FUNCTION__);`
201
202			`try`
203			`{`
204			`m_alloc.set_probability(1);`
205
206			`const size_t size = c.size();`
207			`const size_t native_size = native.size();`
208			`_GLIBCXX_THROW_IF(size != native_size, size << " " << native_size,`
209			`&c, &native);`
210
211			`const bool empty = c.empty();`
212			`const bool native_empty = native.empty();`
213			`_GLIBCXX_THROW_IF(empty != native_empty, empty << " " << native_empty,`
214			`&c, &native);`
215
216			`const size_t it_size = std::distance(c.begin(), c.end());`
217			`_GLIBCXX_THROW_IF(it_size != size, it_size << " " << size, &c, &native);`
218
219			`if (!c.empty())`
220			`{`
221			`const std::string native_top = native.top();`
222			`const std::string top = test_traits::native_value(c.top());`
223			`const bool top_smaller = std::less()(top, native_top);`
224			`const bool top_larger = std::less()(native_top, top);`
225
226			`if (top_smaller \|\| top_larger)`
227			`_GLIBCXX_THROW_IF(true, top << " " << native_top, &c, &native);`
228			`}`
229			`}`
230			`catch(...)`
231			`{`
232			`_GLIBCXX_THROW_IF(true, "call-fn: " + callfn, &c, &native);`
233			`}`
234
235			`notify.cancel();`
236			`}`
237
238			`// Operators.`
239			`PB_DS_CLASS_T_DEC`
240			`void`
241			`PB_DS_CLASS_C_DEC::`
242			`operator()()`
243			`{`
244			`typedef xml_result_set_regression_formatter formatter_type;`
245			`formatter_type* p_fmt = 0;`
246			`if (m_disp)`
247			`p_fmt = new formatter_type(string_form::name(),`
248			`string_form::desc());`
249
250			`m_g.init(m_seed);`
251			`m_alloc.seed(m_seed);`
252
253			`// The __throw_allocator::_S_label defaults to 0, so to make things`
254			`// easier and more precise when debugging, start at 1.`
255			`const size_t starting_label(1);`
256
257			`try`
258			`{`
259			`prog_bar pb(m_n, std::cout, m_disp);`
260
261			`for (m_i = starting_label; m_i <= m_n; ++m_i)`
262			`{`
263			`PB_DS_TRACE("Op #" << m_i);`
264
265			`// Track allocation from this point only.`
266			`allocator_type::set_label(m_i);`
267			`switch(m_i)`
268			`{`
269			`case 1:`
270			`PB_DS_RUN_MTHD(default_constructor);`
271			`break;`
272			`case 2:`
273			`defs();`
274			`break;`
275			`case 3:`
276			`policy_access();`
277			`break;`
278			`case 4:`
279			`it_copy();`
280			`break;`
281			`case 5:`
282			`it_assign();`
283			`break;`
284			`default:`
285			`switch(get_next_op())`
286			`{`
287			`case insert_op:`
288			`PB_DS_RUN_MTHD(push)`
289			`break;`
290			`case modify_op:`
291			`PB_DS_RUN_MTHD(modify)`
292			`break;`
293			`case erase_op:`
294			`switch(get_next_sub_op(3))`
295			`{`
296			`case 0:`
297			`PB_DS_RUN_MTHD(pop)`
298			`break;`
299			`case 1:`
300			`PB_DS_RUN_MTHD(erase_if)`
301			`break;`
302			`case 2:`
303			`PB_DS_RUN_MTHD(erase_it)`
304			`break;`
305			`default:`
306			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
307			`}`
308			`break;`
309			`case clear_op:`
310			`PB_DS_RUN_MTHD(clear)`
311			`break;`
312			`case other_op:`
313			`switch(get_next_sub_op(5))`
314			`{`
315			`case 0:`
316			`swap();`
317			`break;`
318			`case 1:`
319			`PB_DS_RUN_MTHD(copy_constructor)`
320			`break;`
321			`case 2:`
322			`PB_DS_RUN_MTHD(it_constructor)`
323			`break;`
324			`case 3:`
325			`PB_DS_RUN_MTHD(assignment_operator)`
326			`break;`
327			`case 4:`
328			`PB_DS_RUN_MTHD(split_join)`
329			`break;`
330			`default:`
331			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
332			`}`
333			`break;`
334			`default:`
335			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
336			`};`
337			`}`
338			`pb.inc();`
339			`}`
340			`}`
341			`catch (...)`
342			`{`
343			`std::cerr << "Failed at index " << m_i << std::endl;`
344			`delete m_p_c;`
345			`throw;`
346			`}`
347
348			`// Clean up, then check for allocation by special label, set above.`
349			`allocator_type::set_label(0);`
350			`delete m_p_c;`
351
352			`try`
353			`{`
354			`for (size_t n = starting_label; n <= m_n; ++n)`
355			`m_alloc.check_allocated(n);`
356			`}`
357			`catch (std::logic_error& obj)`
358			`{`
359			`// On fail, check_allocated should throw std::logic_error.`
360			`std::cerr << obj.what() << std::endl;`
361			`std::cerr << typeid(Cntnr).name() << std::endl;`
362			`throw;`
363			`}`
364
365			`// Reset throw probability.`
366			`m_alloc.set_probability(0);`
367
368			`if (m_disp)`
369			`{`
370			`std::cout << std::endl;`
371			`delete p_fmt;`
372			`}`
373			`}`
374
375			`PB_DS_CLASS_T_DEC`
376			`typename PB_DS_CLASS_C_DEC::op`
377			`PB_DS_CLASS_C_DEC::`
378			`get_next_op()`
379			`{`
380			`const double prob = m_g.get_prob();`
381
382			`if (prob < m_ip)`
383			`return insert_op;`
384
385			`if (prob < m_ip + m_dp)`
386			`return modify_op;`
387
388			`if (prob < m_ip + m_dp + m_ep)`
389			`return erase_op;`
390
391			`if (prob < m_ip + m_dp + m_ep + m_cp)`
392			`return clear_op;`
393
394			`_GLIBCXX_THROW_IF(prob > 1, prob, m_p_c, &m_native_c);`
395			`return other_op;`
396			`}`
397
398			`PB_DS_CLASS_T_DEC`
399			`size_t`
400			`PB_DS_CLASS_C_DEC::`
401			`get_next_sub_op(size_t max)`
402			`{`
403			`const double p = m_g.get_prob();`
404			`const double delta = 1 / static_cast(max);`
405			`size_t i = 0;`
406			`while (true)`
407			`if (p <= (i + 1) * delta)`
408			`{`
409			`_GLIBCXX_THROW_IF(i >= max, i << " " << max, m_p_c, &m_native_c);`
410			`return i;`
411			`}`
412			`else`
413			`++i;`
414			`}`
415
416			`// Insert.`
417			`PB_DS_CLASS_T_DEC`
418			`bool`
419			`PB_DS_CLASS_C_DEC::`
420			`push()`
421			`{`
422			`PB_DS_TRACE("push");`
423			`bool done = true;`
424			`destructor_printer notify(__FUNCTION__);`
425
426			`try`
427			`{`
428			`m_alloc.set_probability(0);`
429			`value_type v = test_traits::generate_value(m_g, m_m);`
430			`m_alloc.set_probability(m_tp);`
431			`const typename cntnr::size_type sz = m_p_c->size();`
432			`m_p_c->push(v);`
433			`_GLIBCXX_THROW_IF(sz != m_p_c->size() - 1, sz, m_p_c, &m_native_c);`
434			`m_native_c.push(test_traits::native_value(v));`
435			`}`
436			`catch(__gnu_cxx::forced_error&)`
437			`{`
438			`done = false;`
439			`}`
440			`catch(...)`
441			`{`
442			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
443			`}`
444
445			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
446			`notify.cancel();`
447			`return done;`
448			`}`
449
450
451			`// Modify.`
452			`PB_DS_CLASS_T_DEC`
453			`bool`
454			`PB_DS_CLASS_C_DEC::`
455			`modify()`
456			`{`
457			`PB_DS_TRACE("modify");`
458			`destructor_printer notify(__FUNCTION__);`
459
460			`bool done = true;`
461			`try`
462			`{`
463			`m_alloc.set_probability(0);`
464			`value_type v = test_traits::generate_value(m_g, m_m);`
465
466			`m_alloc.set_probability(m_tp);`
467			`typename cntnr::iterator it = m_p_c->begin();`
468			`std::advance(it, m_g.get_unsigned_long(0, m_p_c->size()));`
469			`if (it != m_p_c->end())`
470			`{`
471			`typedef typename test_traits::native_value_type native_value_type;`
472			`native_value_type native_v = test_traits::native_value(*it);`
473			`native_value_type new_native_v = test_traits::native_value(v);`
474			`m_p_c->modify(it, v);`
475			`m_native_c.modify(native_v, new_native_v);`
476			`}`
477			`}`
478			`catch(__gnu_cxx::forced_error&)`
479			`{`
480			`done = false;`
481			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
482			`}`
483
484			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
485			`notify.cancel();`
486			`return done;`
487			`}`
488
489			`// Clear.`
490			`PB_DS_CLASS_T_DEC`
491			`bool`
492			`PB_DS_CLASS_C_DEC::`
493			`clear()`
494			`{`
495			`PB_DS_TRACE("clear");`
496			`m_p_c->clear();`
497			`m_native_c.clear();`
498			`return true;`
499			`}`
500
501			`// Erase.`
502			`PB_DS_CLASS_T_DEC`
503			`bool`
504			`PB_DS_CLASS_C_DEC::`
505			`pop()`
506			`{`
507			`PB_DS_TRACE("pop");`
508			`destructor_printer notify(__FUNCTION__);`
509
510			`bool done = true;`
511			`try`
512			`{`
513			`m_alloc.set_probability(1);`
514			`if (!m_p_c->empty())`
515			`{`
516			`m_p_c->pop();`
517			`m_native_c.pop();`
518			`}`
519			`}`
520			`catch(__gnu_cxx::forced_error&)`
521			`{`
522			`done = false;`
523			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
524			`}`
525
526			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
527			`notify.cancel();`
528			`return done;`
529			`}`
530
531			`PB_DS_CLASS_T_DEC`
532			`bool`
533			`PB_DS_CLASS_C_DEC::`
534			`erase_if()`
535			`{`
536			`PB_DS_TRACE("erase_if");`
537			`destructor_printer notify(__FUNCTION__);`
538
539			`bool done = true;`
540			`try`
541			`{`
542			`typedef`
543			`typename std::iterator_traits::reference`
544			`it_const_reference;`
545
546			`m_alloc.set_probability(1);`
547
548			`typedef`
549			`typename test_traits::template erase_if_fn`
550			`erase_if_fn_t;`
551
552			`const size_t ersd = m_p_c->erase_if(erase_if_fn_t());`
553
554			`typedef`
555			`typename test_traits::template erase_if_fn`
556			`native_erase_if_fn_t;`
557
558			`const size_t native_ersd = m_native_c.erase_if(native_erase_if_fn_t());`
559
560			`_GLIBCXX_THROW_IF(ersd != native_ersd, ersd << " " << native_ersd,`
561			`m_p_c, &m_native_c);`
562			`}`
563			`catch(__gnu_cxx::forced_error&)`
564			`{`
565			`done = false;`
566			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
567			`}`
568
569			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
570			`notify.cancel();`
571			`return done;`
572			`}`
573
574			`PB_DS_CLASS_T_DEC`
575			`bool`
576			`PB_DS_CLASS_C_DEC::`
577			`erase_it()`
578			`{`
579			`PB_DS_TRACE("erase_it");`
580			`destructor_printer notify(__FUNCTION__);`
581
582			`bool done = true;`
583			`try`
584			`{`
585			`m_alloc.set_probability(1);`
586			`typename cntnr::iterator it = m_p_c->begin();`
587			`std::advance(it, m_g.get_unsigned_long(0, m_p_c->size()));`
588
589			`if (it != m_p_c->end())`
590			`{`
591			`m_native_c.erase(*it);`
592			`m_p_c->erase(it);`
593			`}`
594			`}`
595			`catch(__gnu_cxx::forced_error&)`
596			`{`
597			`done = false;`
598			`_GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);`
599			`}`
600
601			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
602			`notify.cancel();`
603			`return done;`
604			`}`
605
606			`// Defs.`
607			`PB_DS_CLASS_T_DEC`
608			`void`
609			`PB_DS_CLASS_C_DEC::`
610			`defs()`
611			`{`
612			`// General container types.`
613			`typedef typename Cntnr::size_type test_size_type;`
614			`typedef typename Cntnr::difference_type difference_type;`
615			`value_defs();`
616			`iterator_defs();`
617			`policy_defs();`
618			`}`
619
620			`PB_DS_CLASS_T_DEC`
621			`void`
622			`PB_DS_CLASS_C_DEC::`
623			`value_defs()`
624			`{`
625			`typedef typename Cntnr::value_type test_value_type;`
626			`typedef typename Cntnr::reference test_reference;`
627			`typedef typename Cntnr::const_reference test_const_reference;`
628			`typedef typename Cntnr::pointer test_pointer;`
629			`typedef typename Cntnr::const_pointer test_const_pointer;`
630			`}`
631
632			`PB_DS_CLASS_T_DEC`
633			`void`
634			`PB_DS_CLASS_C_DEC::`
635			`ds_defs()`
636			`{`
637			`typedef typename Cntnr::container_category test_container_category;`
638			`}`
639
640			`PB_DS_CLASS_T_DEC`
641			`void`
642			`PB_DS_CLASS_C_DEC::`
643			`iterator_defs()`
644			`{`
645			`typedef typename Cntnr::point_iterator test_point_iterator;`
646			`typedef typename Cntnr::point_const_iterator const_test_point_iterator;`
647			`typedef typename Cntnr::iterator test_iterator;`
648			`typedef typename Cntnr::const_iterator const_test_iterator;`
649			`}`
650
651			`PB_DS_CLASS_T_DEC`
652			`void`
653			`PB_DS_CLASS_C_DEC::`
654			`policy_defs()`
655			`{`
656			`typedef typename Cntnr::allocator_type test_allocator;`
657			`typedef typename Cntnr::cmp_fn test_cmp_fn;`
658			`}`
659
660
661			`// Policy access.`
662			`PB_DS_CLASS_T_DEC`
663			`void`
664			`PB_DS_CLASS_C_DEC::`
665			`policy_access()`
666			`{`
667			`PB_DS_TRACE("policy_access");`
668
669			`{`
670			`typename Cntnr::cmp_fn& r_t = m_p_c->get_cmp_fn();`
671			`assert(&r_t);`
672			`}`
673
674			`{`
675			`const typename Cntnr::cmp_fn& r_t =((const Cntnr& )*m_p_c).get_cmp_fn();`
676			`assert(&r_t);`
677			`}`
678			`}`
679
680			`// Split join.`
681			`PB_DS_CLASS_T_DEC`
682			`bool`
683			`PB_DS_CLASS_C_DEC::`
684			`split_join()`
685			`{`
686			`PB_DS_TRACE("split_join");`
687			`destructor_printer notify(__FUNCTION__);`
688
689			`bool done = true;`
690			`try`
691			`{`
692			`m_alloc.set_probability(0);`
693			`Cntnr lhs(*m_p_c);`
694			`Cntnr rhs;`
695			`native_type native_lhs(m_native_c);`
696			`m_alloc.set_probability(m_tp);`
697
698			`typedef typename test_traits::template erase_if_fn split_fn_t;`
699			`lhs.split(split_fn_t(), rhs);`
700
701			`typedef typename test_traits::template erase_if_fn`
702			`native_split_fn_t;`
703
704			`native_type native_rhs;`
705			`native_lhs.split(native_split_fn_t(), native_rhs);`
706			`PB_DS_COND_COMPARE(lhs, native_lhs);`
707			`PB_DS_COND_COMPARE(rhs, native_rhs);`
708
709			`m_alloc.set_probability(m_tp);`
710
711			`if (m_g.get_prob() < 0.5)`
712			`lhs.swap(rhs);`
713			`lhs.join(rhs);`
714
715			`_GLIBCXX_THROW_IF(rhs.size() != 0, rhs.size(), m_p_c, &m_native_c);`
716			`_GLIBCXX_THROW_IF(!rhs.empty(), rhs.size(), m_p_c, &m_native_c);`
717			`}`
718			`catch(__gnu_cxx::forced_error&)`
719			`{`
720			`done = false;`
721			`const bool b = __gnu_pbds::container_traits::split_join_can_throw;`
722			`_GLIBCXX_THROW_IF(!b, b, m_p_c, &m_native_c);`
723			`}`
724
725			`PB_DS_COND_COMPARE(*m_p_c, m_native_c);`
726			`notify.cancel();`
727			`return done;`
728			`}`
729
730			`// Iterator conversions.`
731			`PB_DS_CLASS_T_DEC`
732			`void`
733			`PB_DS_CLASS_C_DEC::`
734			`it_copy()`
735			`{`
736			`PB_DS_TRACE("it_copy");`
737
738			`{`
739			`typename cntnr::iterator it = m_p_c->end();`
740			`typename cntnr::const_iterator const_it(it);`
741			`_GLIBCXX_THROW_IF(const_it != it, "", m_p_c, &m_native_c);`
742			`_GLIBCXX_THROW_IF(!(const_it == it), "", m_p_c, &m_native_c);`
743			`}`
744
745			`{`
746			`typename cntnr::const_iterator const_it = m_p_c->end();`
747			`typename cntnr::point_const_iterator const_find_it(const_it);`
748			`_GLIBCXX_THROW_IF(const_find_it != const_it, "", m_p_c, &m_native_c);`
749			`_GLIBCXX_THROW_IF(!(const_find_it == const_it), "", m_p_c, &m_native_c);`
750			`}`
751
752			`{`
753			`typename cntnr::iterator it = m_p_c->end();`
754			`typename cntnr::point_const_iterator const_find_it1(it);`
755			`_GLIBCXX_THROW_IF(const_find_it1 != it, "", m_p_c, &m_native_c);`
756			`_GLIBCXX_THROW_IF(!(const_find_it1 == it), "", m_p_c, &m_native_c);`
757
758			`typename cntnr::point_iterator find_it1(it);`
759			`_GLIBCXX_THROW_IF(find_it1 != it, "", m_p_c, &m_native_c);`
760			`_GLIBCXX_THROW_IF(!(find_it1 == it), "", m_p_c, &m_native_c);`
761
762			`typename cntnr::point_iterator find_it = m_p_c->end();`
763			`typename cntnr::point_const_iterator const_find_it(find_it);`
764			`_GLIBCXX_THROW_IF(find_it != const_find_it, "", m_p_c, &m_native_c);`
765			`_GLIBCXX_THROW_IF(!(find_it == const_find_it), "", m_p_c, &m_native_c);`
766			`}`
767			`}`
768
769			`PB_DS_CLASS_T_DEC`
770			`void`
771			`PB_DS_CLASS_C_DEC::`
772			`it_assign()`
773			`{`
774			`PB_DS_TRACE("it_assign");`
775
776			`{`
777			`typename cntnr::iterator it = m_p_c->end();`
778			`typename cntnr::const_iterator const_it;`
779			`const_it = it;`
780			`_GLIBCXX_THROW_IF(const_it != it, "", m_p_c, &m_native_c);`
781			`_GLIBCXX_THROW_IF(!(const_it == it), "", m_p_c, &m_native_c);`
782
783			`typename cntnr::point_const_iterator const_find_it;`
784			`const_find_it = it;`
785			`_GLIBCXX_THROW_IF(const_find_it != it, "", m_p_c, &m_native_c);`
786			`_GLIBCXX_THROW_IF(!(const_find_it == it), "", m_p_c, &m_native_c);`
787
788			`typename cntnr::point_iterator find_it;`
789			`find_it = it;`
790			`_GLIBCXX_THROW_IF(find_it != it, "", m_p_c, &m_native_c);`
791			`_GLIBCXX_THROW_IF(!(find_it == it), "", m_p_c, &m_native_c);`
792			`}`
793
794			`{`
795			`typename cntnr::const_iterator const_it = m_p_c->end();`
796			`typename cntnr::point_const_iterator const_find_it;`
797			`const_find_it = const_it;`
798			`_GLIBCXX_THROW_IF(const_find_it != const_it, "", m_p_c, &m_native_c);`
799			`_GLIBCXX_THROW_IF(!(const_find_it == const_it), "", m_p_c, &m_native_c);`
800			`}`
801
802			`{`
803			`typename cntnr::point_iterator find_it = m_p_c->end();`
804			`typename cntnr::point_const_iterator const_find_it;`
805			`const_find_it = find_it;`
806			`_GLIBCXX_THROW_IF(find_it != const_find_it, "", m_p_c, &m_native_c);`
807			`_GLIBCXX_THROW_IF(!(find_it == const_find_it), "", m_p_c, &m_native_c);`
808			`}`
809			`}`
810
811
812			`// Diagnostics.`
813			`PB_DS_CLASS_T_DEC`
814			`void`
815			`PB_DS_CLASS_C_DEC::`
816			`print_container(const native_type& cnt, std::ostream& os) const`
817			`{`
818			`m_alloc.set_probability(0);`
819			`native_type cpy(cnt);`
820			`while (!cpy.empty())`
821			`{`
822			`os << cpy.top() << std::endl;`
823			`cpy.pop();`
824			`}`
825			`}`
826
827			`PB_DS_CLASS_T_DEC`
828			`void`
829			`PB_DS_CLASS_C_DEC::`
830			`print_container(const cntnr& cnt, std::ostream& os) const`
831			`{`
832			`typedef typename cntnr::const_iterator const_iterator;`
833			`m_alloc.set_probability(0);`
834			`for (const_iterator it = cnt.begin(); it != cnt.end(); ++it)`
835			`os << *it << std::endl;`
836			`}`
837
838			`#endif`